def get_user_info(self, auth_token, auth_verifier=""):
    """Get User Info.

    Exchanges the auth token for an access token and returns a dictionary
    of information about the authenticated user.
    """

    auth_token = urlunquote(auth_token)
    auth_verifier = urlunquote(auth_verifier)

    auth_secret = memcache.get(self._get_memcache_auth_key(auth_token))

    if not auth_secret:
      logging.error("The auth token %s is missing from memcache" % auth_token)

    response = self.make_request(self.access_url,
                                 token=auth_token,
                                 secret=auth_secret,
                                 additional_params={"oauth_verifier":
                                                     auth_verifier})

    # Extract the access token/secret from the response.
    result = self._extract_credentials(response)

    # Try to collect some information about this user from the service.
    user_info = self._lookup_user_info(result["token"], result["secret"])
    user_info.update(result)

    return user_info

	def get_user_info(self, auth_token, auth_verifier=""):
		"""Get User Info.
		Exchanges the auth token for an access token and returns a dictionary
		of information about the authenticated user.
		"""

		auth_token = urlunquote(auth_token)
		auth_verifier = urlunquote(auth_verifier)

		auth_secret = memcache.get(self._get_memcache_auth_key(auth_token))

		if not auth_secret:
			result = AuthToken.gql(""" WHERE token = :1 LIMIT 1 """, auth_token).get()

			if not result:
				logging.error("The auth token %s was not found in our db" % auth_token)
				raise Exception, "Could not find Auth Token in database"
			else:
				auth_secret = result.secret

		response = self.make_request(self.access_url,
                        token=auth_token,
                        secret=auth_secret,
                        additional_params={"oauth_verifier":
                                            auth_verifier})

		# Extract the access token/secret from the response.
		result = self._extract_credentials(response)

		# Try to collect some information about this user from the service.
		user_info = self._lookup_user_info(result["token"], result["secret"])
		user_info.update(result)

		return user_info

 def _url2path(self,url):
     """Convert a server-side URL into a client-side path."""
     path = urlunquote(urlparse(url).path)
     root = urlunquote(self._url_p.path)
     path = path[len(root)-1:].decode("utf8")
     while path.endswith("/"):
         path = path[:-1]
     return path

	def get_access_token(self, auth_token, auth_verifier):
		auth_token = urlunquote(auth_token)
		auth_verifier = urlunquote(auth_verifier)
		
		response = self.make_request( self.access_url, 
										token=auth_token,
										additional_params={"oauth_verifier": auth_verifier} )
		result = parse_qs(response.content)
		return result["user_id"][0], result["oauth_token"][0], result["oauth_token_secret"][0]

def urldecode(qs):
    r = []
    for pair in qs.replace(';', '&').split('&'):
        if not pair: continue
        nv = pair.split('=', 1)
        if len(nv) != 2: nv.append('')
        key = urlunquote(nv[0].replace('+', ' '))
        value = urlunquote(nv[1].replace('+', ' '))
        r.append((key, value))
    return r

 def run(self, edit):
     for s in self.view.sel():
         if s.empty():
             s = self.view.word(s)
         selected = self.view.substr(s)
         try:
             txt = urlunquote(selected.encode('utf8')).decode('utf8')
         except TypeError:
             txt = urlunquote(selected)
         self.view.replace(edit, s, txt)

    def get_access_token(self, auth_token, auth_verifier):
        auth_token = urlunquote(auth_token)
        auth_verifier = urlunquote(auth_verifier)

        response = self.make_request(
            self.access_url, token=auth_token, additional_params={"oauth_verifier": auth_verifier}
        )

        # Extract the access token/secret from the response.
        result = self._extract_credentials(response)
        return result["token"], result["secret"], result["screen_name"]

 def from_parsedurl(cls, parsedurl, **kwargs):
     auth, host = urllib2.splituser(parsedurl.netloc)
     password = parsedurl.password
     if password is not None:
         password = urlunquote(password)
     username = parsedurl.username
     if username is not None:
         username = urlunquote(username)
     # TODO(jelmer): This also strips the username
     parsedurl = parsedurl._replace(netloc=host)
     return cls(urlparse.urlunparse(parsedurl),
                password=password, username=username, **kwargs)

  def update_status(self, status,auth_token,auth_verifier=""):
    auth_token = urlunquote(auth_token)
    auth_verifier = urlunquote(auth_verifier)
    global auth_secret
    response = self.make_request(self.access_url,
                                token=auth_token,
                                secret=auth_secret,
                                additional_params={"oauth_verifier":auth_verifier})

    result = self._extract_credentials(response)
    data = self._update_status(result["token"], result["secret"],status)
    return data

  def get_user_info(self, auth_token, auth_verifier=""):
    auth_token = urlunquote(auth_token)
    auth_verifier = urlunquote(auth_verifier)
    global auth_secret
    response = self.make_request(self.access_url,
                                token=auth_token,
                                secret=auth_secret,
                                additional_params={"oauth_verifier":auth_verifier})

    result = self._extract_credentials(response)
    user_info = self._lookup_user_info(result["token"], result["secret"])
    user_info.update(result)
    return user_info

  def get_user_info(self, auth_token, auth_verifier=""):
    """Get User Info.

    Exchanges the auth token for an access token and returns a dictionary
    of information about the authenticated user.
    """

    auth_token = urlunquote(auth_token)
    auth_verifier = urlunquote(auth_verifier)

    auth_secret = memcache.get(self._get_memcache_auth_key(auth_token))

    if not auth_secret:
      result = AuthToken.gql("""
        WHERE
          service = :1 AND
          token = :2
        LIMIT
          1
      """, self.service_name, auth_token).get()

      if not result:
        logging.error("The auth token %s was not found in our db" % auth_token)
        raise Exception, "Could not find Auth Token in database"
      else:
        auth_secret = result.secret

    response = self.make_request(self.access_url,
                                token=auth_token,
                                secret=auth_secret,
                                additional_params={"oauth_verifier":
                                                    auth_verifier})
    key_name = ""
    username = ""
    if self.service_name == 'gdi-acc':
        respdict = parse_qs(response.content)
        username = respdict['user_name']
        key_name = 'id-%s' % uuid4();
    
    # Extract the access token/secret from the response.
    result = self._extract_credentials(response)

    # Try to collect some information about this user from the service.
    #user_info = self._lookup_user_info(result["token"], result["secret"])
    #user_info.update(result)
    
    self.set_cookie(key_name)
    self.set_cookie_username(username[0])
    
    return username[0]

def parse_content(content):
  content_dict = {}
  content_pairs = content.split("&")
  for content_pair in content_pairs:
    k,v = content_pair.split("=")
    content_dict[k] = urlunquote(v)
  return content_dict

  def get_access_token(self, request_token, verifier):
    """Exchanges a Request Token for an Access Token. Returns (access_token, access_secret).
    
    Note that the access_token and access_secret can be stored, allowing future
    requests to be made without going through the happy OAuth dance again.
    """
    request_token, verifier = urlunquote(request_token), urlunquote(verifier)
    request_secret = self._retrieve_request_secret(request_token)

    access_request = self._make_request(self.access_url,
                                       method            = 'POST',
                                       token             = request_token,
                                       secret            = request_secret,
                                       additional_oauth  = {"oauth_verifier": verifier})
    access_response = self._extract_credentials(access_request)
    return (access_response["token"], access_response["secret"])

    def verify(self, request):
        """ verify: Called by the external service to verify you authentication request
        """
        auth_token = urlunquote(request.get("oauth_token"))
        auth_verifier = urlunquote(request.get("oauth_verifier"))

        # Extract the access token/secret from the response.
        response = self._make_request(self.access_token_url, token=auth_token, secret=self.store['oauth_secret'], additional_params={"oauth_verifier": auth_verifier})
        if response.status_code == 200:
            data = self._extract_credentials(response)

            self.user.credentials = OAuth1Credentials(user_token=data['token'], user_secret=data['secret'])

        else:
            raise OAuthClientError(response.status_code, response.content)

        return super(OAuth1Client, self).verify(request)

  def get_user_info(self, auth_token, auth_verifier=''):
    '''Get User Info.

    Exchanges the auth token for an access token and returns a dictionary
    of information about the authenticated user.
    '''

    auth_token = urlunquote(auth_token)
    auth_verifier = urlunquote(auth_verifier)

    auth_secret = memcache.get(self._get_memcache_auth_key(auth_token))

    if not auth_secret:
      result = AuthToken.gql('''
        WHERE
          service = :1 AND
          token = :2
        LIMIT
          1
      ''', self.service_name, auth_token).get()

      if not result:
        logging.error('The auth token %s was not found in our db' % auth_token)
        raise Exception, 'Could not find Auth Token in database'
      else:
        auth_secret = result.secret

    response = self.make_request(self.access_url,
                                 token=auth_token,
                                 secret=auth_secret,
                                 additional_params={'oauth_verifier':
                                                     auth_verifier})

    # Extract the access token/secret from the response.
    result = self._extract_credentials(response)

    # Try to collect some information about this user from the service.
    user_info = self._lookup_user_info(result['token'], result['secret'])
    user_info.update(result)

    return user_info

    def verify(self, request):
        connected = False
        
        if self.version == '1.0':
            auth_token = urlunquote(request.get("oauth_token"))
            auth_verifier = urlunquote(request.get("oauth_verifier"))

            # Extract the access token/secret from the response.
            response = self._make_request(self.access_url, token=auth_token, secret=self.tokens.oauth_secret, additional_params={"oauth_verifier": auth_verifier})
            if response.status_code == 200:
                data = self._extract_credentials(response)
                self.modified = datetime.datetime.now()
                self.tokens.oauth_user_token = data['token']
                self.tokens.oauth_user_secret = data['secret']
                self.tokens.put()
                connected = True
        
        elif self.version == '2.0':
            # prepare a post to get the access code
            params = {
                "grant_type": "authorization_code",
                "client_id": self.consumer_key,
                "client_secret": self.consumer_secret,
                "redirect_uri": self.callback_url
            }
            params_str = "code=" + request.get("code") + "&" + urlencode(params)
            response = urlfetch.fetch(self.access_url, method=urlfetch.POST, payload=params_str, deadline=20, follow_redirects=True)
            if response.status_code == 200:
                data = json.loads(response.content)
                self.tokens.modified = datetime.datetime.now()
                self.tokens.oauth_access_token = data["access_token"]
                self.tokens.oauth_refresh_token = data["refresh_token"]
                self.tokens.oauth_expires_in = data["expires_in"]
                self.tokens.put()
                connected = True

            else:
                raise Error(response.status_code, response.content)

        if connected:       # Get the user information
            self.setUserInfo()

 def _cover_from_html(self, hcover):
     from calibre.ebooks import render_html_svg_workaround
     with TemporaryDirectory('_html_cover') as tdir:
         writer = OEBWriter()
         writer(self.oeb, tdir)
         path = os.path.join(tdir, urlunquote(hcover.href))
         data = render_html_svg_workaround(path, self.logger)
         if not data:
             data = ''
     id, href = self.oeb.manifest.generate('cover', 'cover.jpg')
     item = self.oeb.manifest.add(id, href, JPEG_MIME, data=data)
     return item

    def get_user_info(self, auth_token, auth_verifier="", detailed_info=False):
        """Get User Info.

        Exchanges the auth token for an access token and returns a dictionary
        of information about the authenticated user.
        """

        auth_token = urlunquote(auth_token)
        auth_verifier = urlunquote(auth_verifier)

        key = AuthToken.key_name(self.service_name, auth_token)
        auth_model = memcache.get(key)  # @UndefinedVariable

        if not auth_model:
            auth_model = AuthToken.get_by_key_name(key)

            if not auth_model:
                logging.error("The auth token %s was not found in our db" % auth_token)
                raise Exception, "Could not find Auth Token in database"

        if not auth_model.auth_token:
            response = self.make_request(self.access_url, token=auth_token, secret=auth_model.secret,
                                         additional_params={"oauth_verifier": auth_verifier})

            # Extract the access token/secret from the response.
            result = self._extract_credentials(response)
            auth_model.auth_token = json.dumps(result)
            auth_model.put()
            memcache.set(key, auth_model, 20 * 60)  # @UndefinedVariable
        else:
            result = json.loads(auth_model.auth_token)

        # Try to collect some information about this user from the service.
        if detailed_info:
            user_info = self._lookup_user_info(result["token"], result["secret"])
            user_info.update(result)
            return user_info
        else:
            return result

    def href_to_name(self, href, base=None):
        """
        Convert an href (relative to base) to a name (i.e. a path
        relative to self.root with POSIX separators).

        base must be an absolute path with OS separators or None, in which case
        the href is interpreted relative to the dir containing the OPF.
        """
        if base is None:
            base = self.opf_dir
        href = urlunquote(href.partition("#")[0])
        fullpath = os.path.join(base, *href.split("/"))
        return self.abspath_to_name(fullpath)

def lambda_handler(event, context):
    bucketname = 'dbarnetttestimageforlambda'
    tilex, tiley = urlunquote(event['coords']).strip("()").replace(' ', '').split(',')
    zoom = event['zoom']
    keyname = Key="%s:%s:%s" % (zoom, tilex, tiley)
    s3 = boto3.resource('s3')
    try:
        #s3.Bucket(bucketname).get_object(keyname)
        s3.Object(bucketname, keyname).load()
    except botocore.exceptions.ClientError as e:
        Mandel(int(zoom), int(tilex), int(tiley))
        s3.Bucket(bucketname).put_object(Key=keyname, Body=open('/tmp/tile.png', 'rb'))
    return json.loads('{"location": "https://s3-us-west-2.amazonaws.com/%s/%s"}' % (bucketname, keyname))