def getMapUrl(mapType, width, height, lat, lng, zoom):
    urlbase = "http://maps.google.com/maps/api/staticmap?"
    params = ''
    if len(tweetListBox.curselection()) != 0:
        selected = tweetListBox.curselection()[0]
        if testtwitter.tweets[selected]['coordinates'] is not None:
            tweetCoord = testtwitter.tweets[selected]['coordinates']['coordinates']
            params = "maptype={}&center={},{}&zoom={}&size={}x{}&format=gif&markers=color:red%7C{},{}&markers=color:blue%7Csize:small".format(mapType, lat, lng, zoom, width, height, tweetCoord[1], tweetCoord[0])
        else:
            params = "maptype={}&center={},{}&zoom={}&size={}x{}&format=gif&markers=color:red%7C{}&markers=color:blue%7Csize:small".format(mapType, lat, lng, zoom, width, height, quote_plus(testtwitter.tweets[selected]['user']['location']))

        counter = 0
        for tweet in testtwitter.tweets:
            if counter == selected:
                counter += 1
                continue
            if tweet['coordinates'] is not None:
                tweetCoord = tweet['coordinates']['coordinates']
                params += "%7C{},{}".format(tweetCoord[1], tweetCoord[0])
            else:
                params += "%7C{}".format(quote_plus(tweet['user']['location']))
            counter += 1
    else:
        params = "maptype={}&center={},{}&zoom={}&size={}x{}&format=gif&markers=color:blue%7Csize:small".format(mapType, lat, lng, zoom, width, height)
        for tweet in testtwitter.tweets:
            if tweet['coordinates'] is not None:
                tweetCoord = tweet['coordinates']['coordinates']
                params += "%7C{},{}".format(tweetCoord[1], tweetCoord[0])
            else:
                params += "%7C{}".format(quote_plus(tweet['user']['location']))
    return urlbase + params

 def _get_search_content(self, kind, ton, results):
     """Retrieve the web page for a given search.
     kind can be 'tt' (for titles), 'nm' (for names),
     'char' (for characters) or 'co' (for companies).
     ton is the title or the name to search.
     results is the maximum number of results to be retrieved."""
     if isinstance(ton, unicode):
         try:
             ton = ton.encode('utf-8')
         except Exception as e:
             try:
                 ton = ton.encode('iso8859-1')
             except Exception as e:
                 pass
     ##params = 'q=%s&%s=on&mx=%s' % (quote_plus(ton), kind, str(results))
     params = 'q=%s&s=%s&mx=%s' % (quote_plus(ton), kind, str(results))
     if kind == 'ep':
         params = params.replace('s=ep&', 's=tt&ttype=ep&', 1)
     cont = self._retrieve(self.urls['find'] % params)
     #print 'URL:', imdbURL_find % params
     if cont.find('Your search returned more than') == -1 or \
             cont.find("displayed the exact matches") == -1:
         return cont
     # The retrieved page contains no results, because too many
     # titles or names contain the string we're looking for.
     params = 'q=%s&ls=%s&lm=0' % (quote_plus(ton), kind)
     size = 131072 + results * 512
     return self._retrieve(self.urls['find'] % params, size=size)

    def setUp(self):
        self.user = User.objects.create_user('rulz', '[email protected]', '12345')
        self.task = Task.objects.create(
            name='tarea', description='description tarea', owner=self.user
        )

        #oauth2_provider para crear los token al usuario que se loguea
        self.application = Application(
            name="todo",
            user=self.user,
            client_type=Application.CLIENT_PUBLIC,
            authorization_grant_type=Application.GRANT_PASSWORD,
        )
        self.application.save()

        self.token_request_data = {
            'grant_type': 'password',
            'username': 'rulz',
            'password': '12345'
        }

        self.auth_headers = self.get_basic_auth_header(
            urllib.quote_plus(self.application.client_id),
            urllib.quote_plus(self.application.client_secret)
        )

        self.response = self.client.post(reverse('oauth2_provider:token'),
                                         data=self.token_request_data, **self.auth_headers)
        content = json.loads(self.response.content.decode("utf-8"))
        self.headers = {'Authorization': 'Bearer %(token)s' % {'token': content['access_token']}}

    def instance_url(self):
        extn = quote_plus(self.id)

        if hasattr(self, "customer"):
            customer = self.customer

            base = Customer.class_url()
            owner_extn = quote_plus(customer)
            class_base = "sources"

        elif hasattr(self, "recipient"):
            recipient = self.recipient

            base = Recipient.class_url()
            owner_extn = quote_plus(recipient)
            class_base = "cards"

        elif hasattr(self, "account"):
            account = self.account

            base = Account.class_url()
            owner_extn = quote_plus(account)
            class_base = "external_accounts"

        else:
            raise error.InvalidRequestError(
                "Could not determine whether card_id %s is attached to a customer, " "recipient, or account." % self.id,
                "id",
            )

        return "%s/%s/%s/%s" % (base, owner_extn, class_base, extn)

    def search(self, query):
        self.query = query
        params = []
        hparams = {
            'q': self.query,
            'group': self.group,
            'nresults': self.nresults,
            'start': self.start,
            'match':self.match,
            'nocollapse': 'true' if self.nocollapse else 'false',
            'nfo': 'true' if self.nfo else 'false',
            'passwd': 'true' if self.passwd else 'false',
            'complete': self.complete,
            'key': Request.key
        }
        for param in iter(hparams):
            if hparams[param]: 
                params.append('%s=%s' % (
                    quote_plus(str(param)), 
                    quote_plus(str(hparams[param]))))
        url = '%s?%s' % (Request.url, '&'.join(params))

        print(url)
        content = urlopen(url).read().decode('utf-8')

        return Result(json.loads(content))

def get_games_with_system(search, system):
    scraper_sysid = __scrapermap__[system]
    results = []
    try:
        req = request.Request('http://thegamesdb.net/api/GetGamesList.php?name='+parse.quote_plus(search)+'&platform='+parse.quote_plus(scraper_sysid))
        req.add_unredirected_header('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31')
        f = request.urlopen(req)
        page = f.read().decode('utf-8').replace('\n','')
        if system == "Sega Genesis":
            req = request.Request('http://thegamesdb.net/api/GetGamesList.php?name='+parse.quote_plus(search)+'&platform='+parse.quote_plus('Sega Mega Drive'))
            req.add_unredirected_header('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31')
            f2 = request.urlopen(req)
            page = page + f2.read().replace("\n", "")
        games = re.findall("<Game><id>(.*?)</id><GameTitle>(.*?)</GameTitle>(.*?)<Platform>(.*?)</Platform></Game>",
                           page)
        for item in games:
            game = {}
            game["id"] = item[0]
            game["title"] = item[1]
            game["system"] = item[3]
            game["order"] = 1
            if game["title"].lower() == search.lower():
                game["order"] += 1
            if game["title"].lower().find(search.lower()) != -1:
                game["order"] += 1
            if game["system"] == scraper_sysid:
                game["system"] = system
                results.append(game)
        results.sort(key=lambda result: result["order"], reverse=True)
        return [SearchResult(result["title"], result["id"]) for result in results]
    except:
        return None

def create_facebook_button(url, quote, hashtags, config):
    return config['snippet_facebook'].format(
        url=url,
        urlq=quote_plus(url),
        quote=quote_plus((quote + format_hashtags(hashtags)).encode('utf-8')),
        icon_facebook=config['icon_facebook']
    )

    def get_pinterets_share_link(self,
                                 URL: str,
                                 media: str,
                                 description: str="",
                                 **kwargs) -> str:
        """
        Creates Pinterest share (pin) link with the UTM parameters.

        Arguments:
            URL -- Link that you want to share.
            media -- Media URL to pin.
            description (optional) -- Describe your pin.

        Keyword Arguments:
            You can pass query string parameters as keyword arguments.
            Example: utm_source, utm_medium, utm_campaign etc...

        Returns:
            URL -- Pinterest share (pin) link for the URL.
        """

        if "utm_source" not in kwargs:
            kwargs["utm_source"] = "pinterest"

        link = ("http://pinterest.com/pin/create/button/"
                "?media={media}&description={description}&url={URL}?{args}")
        link = link.format(
            URL=quote_plus(URL),
            media=quote_plus(media),
            description=quote_plus(description),
            args=quote_plus(urlencode(kwargs)),
        )

        return link

 def url(self):
     query = []
     if self.language is not None:
         query.append("l={}".format(quote_plus(self.language)))
     if self.since is not None:
         query.append("since={}".format(quote_plus(self.since)))
     return "https://github.com/trending?" + "&".join(query)

def print_conf(c):
    iss, tag = c.split('][', 2)
    fname= os.path.join('entities', quote_plus(unquote_plus(iss)), quote_plus(unquote_plus(tag)))
    cnf = json.loads(open(fname,'r').read())
    print(">>>", fname)
    print(json.dumps(cnf, sort_keys=True, indent=2,
                     separators=(',', ': ')))

def main():
    try:
        aws_secret_key = os.environ['AWS_SECRET_ACCESS_KEY']
        aws_access_key = os.environ['AWS_ACCESS_KEY_ID']
    except KeyError:
        print("Please set your AWS_SECRET_ACCESS_KEY and AWS_ACCESS_KEY_ID environment variables.")
        return 1

    args = parse_args()

    connection = client.connect(args.host, error_trace=True)
    cur = connection.cursor()

    create_table(cur, os.path.join(os.path.dirname(__file__), "..", "schema.sql"))
    alter_table(cur, 0)

    for month in get_month_partitions(args.start, args.end):
        print('Importing Github data for {0} ...'.format(month))
        s3_url = 's3://{0}:{1}@crate.sampledata/github_archive/{2}-*'.format(quote_plus(aws_access_key),
            quote_plus(aws_secret_key), month)
        print('>>> {0}'.format(s3_url))
        cmd = '''COPY github PARTITION (month_partition=?) FROM ? WITH (compression='gzip')'''
        try:
            cur.execute(cmd, (month, s3_url,))
        except Exception as e:
            print("Error while importing {}: {}".format(s3_url, e))
            print(e.error_trace)

    alter_table(cur, 1)
    return 0

    def put(self, key, value, cache=None, options={}):
        """Query the server to set the key specified to the value specified in
        the specified cache.

        Keyword arguments:
        key -- the name of the key to be set. Required.
        value -- the value to set key to. Must be a string or JSON
                 serialisable. Required.
        cache -- the cache to store the item in. Defaults to None, which uses
                 self.name. If no name is set, raises a ValueError.
        options -- a dict of arguments to send with the request. See
                   http://dev.iron.io/cache/reference/api/#put_item for more
                   information on defaults and possible values.
        """
        if cache is None:
            cache = self.name
        if cache is None:
            raise ValueError("Cache name must be set")

        if not isinstance(value, six.string_types) and not isinstance(value,
                six.integer_types):
            value = json.dumps(value)

        options["body"] = value
        body = json.dumps(options)

        cache = quote_plus(cache)
        key = quote_plus(key)

        result = self.client.put("caches/%s/items/%s" % (cache, key), body,
                {"Content-Type": "application/json"})
        return Item(cache=cache, key=key, value=value)

def make_webenv(config, rest):
    if args.tag:
        qtag = quote_plus(args.tag)
    else:
        qtag = 'default'

    ent_conf = None
    try:
        ent_conf = rest.construct_config(quote_plus(args.issuer), qtag)
    except Exception as err:
        print('iss:{}, tag:{}'.format(quote_plus(args.issuer), qtag))
        for m in traceback.format_exception(*sys.exc_info()):
            print(m)
        exit()

    setup_logging("%s/rp_%s.log" % (SERVER_LOG_FOLDER, args.port), logger)
    logger.info('construct_app_args')

    _path, app_args = construct_app_args(args, config, oper, func, profiles,
                                         ent_conf)

    # Application arguments
    app_args.update(
        {"msg_factory": oic_message_factory, 'profile_map': PROFILEMAP,
         'profile_handler': ProfileHandler,
         'client_factory': Factory(Client)})

    if args.insecure:
        app_args['client_info']['verify_ssl'] = False

    return app_args

def _get_bearer_token(key, secret):
    """
    OAuth2 function using twitter's "Application Only" auth method.
    With key and secret, make a POST request to get a bearer token that is used in future API calls
    """

    creds = parse.quote_plus(key) + ':' + parse.quote_plus(secret)
    encoded_creds = base64.b64encode(creds.encode('ascii'))

    all_headers = {
        "Authorization": "Basic " + encoded_creds.decode(encoding='UTF-8'),
        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
        "User-Agent": API_USER_AGENT,
    }

    body_content = {
        'grant_type': 'client_credentials'
    }

    resp = requests.post(
        'https://api.twitter.com/oauth2/token',
        data=body_content,
        headers=all_headers
    )

    json = resp.json()

    if json['token_type'] != 'bearer' or 'access_token' not in json:
        raise OAuthError("Did not receive proper bearer token on initial POST")

    return json['access_token']

 def set_ethernet_if(self, cmd_list, if_id,
                     ip_address, descr):
     if_cmd = self.get_interface()
     cmd_list.append(VyattaSetAPICall("interfaces/{0}/{1}/address/{2}"
                                      .format(if_cmd, if_id, quote_plus(ip_address))))
     cmd_list.append(VyattaSetAPICall("interfaces/{0}/{1}/description/{2}"
                                      .format(if_cmd, if_id, quote_plus(descr))))

 def delete(self, entity, id):
     """Deletes a single entity row from an entity repository."""
     response = self.session.delete(
         self.url + "v1/" + quote_plus(entity) + "/" + quote_plus(id), headers=self._get_token_header()
     )
     response.raise_for_status()
     return response

	def validate(self,dic):
		params = {}

		openid_endpoint = dic["openid.op_endpoint"]
		signed = dic["openid.signed"].split(",")
		for item in signed:
			params["openid."+item] = parse.quote_plus(dic["openid."+item])
		params['openid.mode'] = 'check_authentication'

		params["openid.assoc_handle"] = dic['openid.assoc_handle'] 
		params["openid.signed"] = dic['openid.signed']
		params["openid.sig"] = parse.quote_plus(dic['openid.sig'])
		params["openid.ns"] = 'http://specs.openid.net/auth/2.0'

		data = "?"
		for key, value in params.items():
			data += key+"="+value+"&"
		data = data[:-1]
		print("https://steamcommunity.com/openid/login"+data)
		check = requests.get("https://steamcommunity.com/openid/login"+data)
		check = str(check.content)
		if check.split("\\n")[1] == "is_valid:true":
			return dic["openid.claimed_id"]
		else:
			return False

 def get_attribute_meta_data(self, entity, attribute):
     """Retrieves the metadata for a single attribute of an entity repository."""
     response = self.session.get(
         self.url + "v1/" + quote_plus(entity) + "/meta/" + quote_plus(attribute), headers=self._get_token_header()
     ).json()
     response.raise_for_status()
     return response

    def url(self):
        """
Returns the URL used for all subsequent requests.

:return: (str) URL to be called
:since:  v1.0.0
        """

        _return = "{0}://".format(self.scheme)

        if (self.auth_username is not None or self.auth_password is not None):
            if (self.auth_username is not None): _return += quote_plus(self.auth_username)
            _return += ":"
            if (self.auth_password is not None): _return += quote_plus(self.auth_password)
            _return += "@"
        #

        _return += self.host

        if ((self.scheme != "https" or self.port != http_client.HTTPS_PORT)
                and (self.scheme != "http" or self.port != http_client.HTTP_PORT)
        ): _return += ":{0:d}".format(self.port)

        _return += self.path

        return _return

def series_api(key, value=None):
	query = quote_plus(key)
	if value is not None:
		query += "=" + quote_plus(value)
	url = urljoin(iview_config['api_url'], '?' + query)
	index_data = maybe_fetch(url)
	return parser.parse_series_api(index_data)