Python urlparse.parse_qsl函数代码示例

 def test_get_download_url_aurora_l10n(self):
     """Aurora non en-US should have a slightly different product name."""
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'win', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-aurora-latest-l10n'),
                           ('os', 'win'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'win64', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-aurora-latest-l10n'),
                           ('os', 'win64'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'osx', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-aurora-latest-l10n'),
                           ('os', 'osx'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'linux', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-aurora-latest-l10n'),
                           ('os', 'linux'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'linux64', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-aurora-latest-l10n'),
                           ('os', 'linux64'),
                           ('lang', 'pt-BR')])

    def get_download_url_ssl(self):
        """
        SSL-enabled links should always be used except Windows stub installers.
        """

        # SSL-enabled links won't be used for Windows builds (but SSL download
        # is enabled by default for stub installers)
        url = firefox_desktop.get_download_url('release', '27.0', 'win', 'pt-BR', True)
        self.assertListEqual(parse_qsl(urlparse(url).query),
                             [('product', 'firefox-27.0'),
                              ('os', 'win'),
                              ('lang', 'pt-BR')])

        # SSL-enabled links will be used for OS X builds
        url = firefox_desktop.get_download_url('release', '27.0', 'osx', 'pt-BR', True)
        self.assertListEqual(parse_qsl(urlparse(url).query),
                             [('product', 'firefox-27.0-SSL'),
                              ('os', 'osx'),
                              ('lang', 'pt-BR')])

        # SSL-enabled links will be used for Linux builds
        url = firefox_desktop.get_download_url('release', '27.0', 'linux', 'pt-BR', True)
        self.assertListEqual(parse_qsl(urlparse(url).query),
                             [('product', 'firefox-27.0-SSL'),
                              ('os', 'linux'),
                              ('lang', 'pt-BR')])

    def get_download_url_ssl(self):
        """
        SSL-enabled links should be used for the specific verions, except the
        Windows stub installers.
        """

        # SSL-enabled links won't be used for 26.0
        url = firefox_details.get_download_url("OS X", "pt-BR", "26.0")
        self.assertListEqual(
            parse_qsl(urlparse(url).query), [("product", "firefox-26.0"), ("os", "osx"), ("lang", "pt-BR")]
        )

        # SSL-enabled links won't be used for 27.0 Windows builds (but SSL
        # download is enabled by default for stub installers)
        url = firefox_details.get_download_url("Windows", "pt-BR", "27.0")
        self.assertListEqual(
            parse_qsl(urlparse(url).query), [("product", "firefox-27.0"), ("os", "win"), ("lang", "pt-BR")]
        )

        # SSL-enabled links will be used for 27.0 OS X builds
        url = firefox_details.get_download_url("OS X", "pt-BR", "27.0")
        self.assertListEqual(
            parse_qsl(urlparse(url).query), [("product", "firefox-27.0-SSL"), ("os", "osx"), ("lang", "pt-BR")]
        )

        # SSL-enabled links will be used for 27.0 Linux builds
        url = firefox_details.get_download_url("Linux", "pt-BR", "27.0")
        self.assertListEqual(
            parse_qsl(urlparse(url).query), [("product", "firefox-27.0-SSL"), ("os", "linux"), ("lang", "pt-BR")]
        )

def collect_parameters(uri_query=None, authorization_header=None, body=None, exclude_oauth_signature=True):
    """Collect parameters from the uri query, authorization header, and request
    body.
    Per `section 3.4.1.3.1`_ of the spec.

    .. _`section 3.4.1.3.1`: http://tools.ietf.org/html/rfc5849#section-3.4.1.3.1
    """
    params = []

    if uri_query is not None:
        params.extend(urlparse.parse_qsl(uri_query))

    if authorization_header is not None:
        params.extend(utils.parse_authorization_header(authorization_header))

    if body is not None:
        params.extend(urlparse.parse_qsl(body))

    exclude_params = [u"realm"]
    if exclude_oauth_signature:
        exclude_params.append(u"oauth_signature")

    params = filter(lambda i: i[0] not in exclude_params, params)

    return params

 def test_get_download_url_nightly_full(self):
     """
     The Aurora version should give us a bouncer url. For Windows, a full url
     should be returned.
     """
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'win', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-ssl'),
                           ('os', 'win'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'win64', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-ssl'),
                           ('os', 'win64'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'osx', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-ssl'),
                           ('os', 'osx'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'linux', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-ssl'),
                           ('os', 'linux'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'linux64', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-ssl'),
                           ('os', 'linux64'),
                           ('lang', 'en-US')])

 def test_get_download_url_devedition_full(self):
     """
     The Developer Edition version should give us a bouncer url. For Windows,
     a full url should be returned.
     """
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'win', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-devedition-latest-ssl'),
                           ('os', 'win'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'win64', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-devedition-latest-ssl'),
                           ('os', 'win64'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'osx', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-devedition-latest-ssl'),
                           ('os', 'osx'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'linux', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-devedition-latest-ssl'),
                           ('os', 'linux'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('alpha', '28.0a2', 'linux64', 'en-US', True, True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-devedition-latest-ssl'),
                           ('os', 'linux64'),
                           ('lang', 'en-US')])

 def test_get_download_url_nightly_l10n(self):
     """
     The Nightly version should give us a bouncer url. A stub url should be
     returned for win32/64, while other platforms get a full url. The product
     name is slightly different from en-US.
     """
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'win', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-stub'),
                           ('os', 'win'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'win64', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-stub'),
                           ('os', 'win64'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'osx', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-l10n-ssl'),
                           ('os', 'osx'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'linux', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-l10n-ssl'),
                           ('os', 'linux'),
                           ('lang', 'pt-BR')])
     url = firefox_desktop.get_download_url('nightly', '50.0a1', 'linux64', 'pt-BR', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-nightly-latest-l10n-ssl'),
                           ('os', 'linux64'),
                           ('lang', 'pt-BR')])

def twitter():
    request_token_url = 'https://api.twitter.com/oauth/request_token'
    access_token_url = 'https://api.twitter.com/oauth/access_token'
    authenticate_url = 'https://api.twitter.com/oauth/authenticate'

    if request.args.get('oauth_token') and request.args.get('oauth_verifier'):
        auth = OAuth1(app.config['TWITTER_CONSUMER_KEY'],
                      client_secret=app.config['TWITTER_CONSUMER_SECRET'],
                      resource_owner_key=request.args.get('oauth_token'),
                      verifier=request.args.get('oauth_verifier'))
        r = requests.post(access_token_url, auth=auth)
        profile = dict(parse_qsl(r.text))

        user = User.query.filter_by(twitter=profile['user_id']).first()
        if user:
            token = create_token(user)
            return jsonify(token=token)

        u = User(twitter=profile['user_id'],
                 display_name=profile['screen_name'],
                 oauth_token=profile['oauth_token'],
                 oauth_token_secret=profile['oauth_token_secret'])
        db.session.add(u)
        db.session.commit()
        token = create_token(u)
        return jsonify(token=token)
    else:
        oauth = OAuth1(app.config['TWITTER_CONSUMER_KEY'],
                       client_secret=app.config['TWITTER_CONSUMER_SECRET'],
                       callback_uri=app.config['TWITTER_CALLBACK_URL'])
        r = requests.post(request_token_url, auth=oauth)
        oauth_token = dict(parse_qsl(r.text))
        qs = urlencode(dict(oauth_token=oauth_token['oauth_token']))
        return redirect(authenticate_url + '?' + qs)

    def link_account(self, widget,consumer_key,consumer_secret):
        consumer_key = consumer_key.get_text()
        consumer_secret = consumer_secret.get_text()
        
        consumer = oauth.Consumer(consumer_key, consumer_secret)
        client = oauth.Client(consumer)

        resp, content = client.request(self.config_data['request_token_url'], "POST", urllib.urlencode({'oauth_callback':'oob'}))
        if resp['status'] == '200':
            request_token = dict(urlparse.parse_qsl(content))
            oauth_verifier = self.show_dialog("Click <a href='%s?oauth_token=%s'>HERE</a>, authorize the application and copy the pin:" % (self.config_data['authorize_url'], request_token['oauth_token']),"")
         
            token = oauth.Token(request_token['oauth_token'],request_token['oauth_token_secret'])
            token.set_verifier(oauth_verifier)
            client = oauth.Client(consumer, token)

            resp, content = client.request(self.config_data['access_token_url'], "POST")
            if resp['status'] == '200':
                access_token = dict(urlparse.parse_qsl(content))

                self.config_data['oauth_token'] = access_token['oauth_token']
                self.config_data['oauth_token_secret'] = access_token['oauth_token_secret']
                self.save_config_file()

                self.show_dialog("The application was successfully authorized.",None)
            else:
                self.show_dialog("There was an error in authorizing the application. Please verify that you granted access to the application and inputed the pin correctly.",None)
        else:
            self.show_dialog("Invalid response from server. Please verify the consumer key and secret.",None)    

def get_access(client):
    if os.path.exists("access.db"):
        return load_access()


    response, content = make_request(client,request_token_url,{},"Failed to fetch request token","POST")

    # parse out the tokens from the response
    request_token = dict(urlparse.parse_qsl(content))
    print "Go to the following link in your browser:"
    print "%s?oauth_token=%s" % (authorize_url, request_token['oauth_token'])
 
    # ask for the verifier pin code
    oauth_verifier = raw_input('What is the PIN? ')
 
    # swap in the new token + verifier pin
    token = oauth.Token(request_token['oauth_token'],request_token['oauth_token_secret'])
    token.set_verifier(oauth_verifier)
    client = oauth.Client(consumer, token)
 
    # fetch the access token
    response, content = make_request(client,access_token_url,{},"Failed to fetch access token","POST")

    # parse out the access token
    access_token = dict(urlparse.parse_qsl(content))
    print "Access Token:"
    print "    - oauth_token        = %s" % access_token['oauth_token']
    print "    - oauth_token_secret = %s" % access_token['oauth_token_secret']
    print

    database = shelve.open("access.db")
    database['access'] = access_token
    database.close()

    return access_token 

    def tokens(self):

        consumer = oauth2.Consumer(self.consumer_token, self.consumer_secret)
        client = oauth2.Client(consumer)

        # Request request tokens
        resp, content = client.request(self.request_token_url, "GET")

        if resp['status'] != '200':
            raise Exception("Invalid response %s." % resp['status'])

        request_token = dict(urlparse.parse_qsl(content))

        logging.debug("Request Token:\n" +
                      "    - oauth_token        = {0[oauth_token]}\n".format(request_token) +
                      "    - oauth_token_secret = {0[oauth_token_secret]}\n".format(request_token))

        # interactively ask for permission/connect to the account
        verifier = self.verifier("%s?oauth_token=%s" % (self.authorize_url, request_token['oauth_token']))

        token = oauth2.Token(request_token['oauth_token'],
                             request_token['oauth_token_secret'])
        token.set_verifier(verifier)

        # convert request token + verifier token into access token
        client = oauth2.Client(consumer, token)
        resp, content = client.request(self.access_token_url, "POST")

        access_token = dict(urlparse.parse_qsl(content))
        return access_token

def get_access_token(consumer):

  client = oauth.Client(consumer)

  resp, content = client.request(request_token_url, "GET")
  if resp['status'] != '200':
      raise Exception("Invalid response %s." % resp['status'])

  request_token = dict(urlparse.parse_qsl(content))


  print "[ACTION] Go to the following link in your browser:"
  print "%s?oauth_token=%s" % (authorize_url, request_token['oauth_token'])
  print 

  accepted = 'n'
  while accepted.lower() == 'n':
      accepted = raw_input('Have you authorized me? (y/n) ')
  oauth_verifier = raw_input('What is the PIN? ')

  token = oauth.Token(request_token['oauth_token'],
      request_token['oauth_token_secret'])
  token.set_verifier(oauth_verifier)
  client = oauth.Client(consumer, token)

  resp, content = client.request(access_token_url, "POST")
  access_token = dict(urlparse.parse_qsl(content))

  return access_token

def oauth_requests():
    auth = OAuth1(AK.API_KEY, AK.SECRET_KEY, callback_uri=callback_uri)
    #print auth
    r = requests.post(request_url, auth=auth)
    #print r
    request_token = dict(urlparse.parse_qsl(r.text))
    #print request_token

    # Getting the User Authorization
    # ブラウザを開きOAuth認証確認画面を表示
    # ユーザーが許可するとPINコードが表示される
    url = '{0}?oauth_token={1}&perms=write'.format(authorize_url,  request_token['oauth_token'])
    #print testurl
    #print MI.BROWSER_PATH
    browser = webbrowser.get(MI.BROWSER_PATH)
    browser.open(url)

    oauth_verifier = raw_input("[PIN Code]> ")  # 上記PINコードを入力する
    #print oauth_verifier
    auth = OAuth1(
            AK.API_KEY,
            AK.SECRET_KEY,
            request_token['oauth_token'],
            request_token['oauth_token_secret'],
            verifier=oauth_verifier)
    r = requests.post(access_token_url, auth=auth)

    access_token = dict(urlparse.parse_qsl(r.text))
    return access_token

    def _get_access_tokens(self):
        oauth_consumer = oauth2.Consumer(key=self.CONSUMER_KEY,
                                        secret=self.CONSUMER_SECRET)
        oauth_client = oauth2.Client(oauth_consumer)

        resp, content = oauth_client.request(twitter.REQUEST_TOKEN_URL, 'GET')

        if resp['status'] != '200':
            print('Invalid respond from Twitter requesting temp token: %s'
                  % resp['status'])
            return

        request_token = dict(urlparse.parse_qsl(content))
        webbrowser.open('%s?oauth_token=%s' % (twitter.AUTHORIZATION_URL,
                                               request_token['oauth_token']))
        pincode = raw_input('Enter pincode')
        token = oauth2.Token(request_token['oauth_token'],
                            request_token['oauth_token_secret'])
        token.set_verifier(pincode)
        oauth_client  = oauth2.Client(oauth_consumer, token)
        resp, content = oauth_client.request(twitter.ACCESS_TOKEN_URL,
            method='POST', body='oauth_verifier=%s' % pincode)

        if resp['status'] != '200':
            print('Invalid respond from Twitter requesting access token: %s'
                  % resp['status'])
            return

        access_token  = dict(urlparse.parse_qsl(content))
        request_token = dict(urlparse.parse_qsl(content))

        return access_token['oauth_token'], access_token['oauth_token_secret']

 def test_get_download_url_esr(self):
     """
     The ESR version should give us a bouncer url. There is no stub for ESR.
     """
     url = firefox_desktop.get_download_url('esr', '28.0a2', 'win', 'en-US', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-esr-latest-ssl'),
                           ('os', 'win'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('esr', '28.0a2', 'win64', 'en-US', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-esr-latest-ssl'),
                           ('os', 'win64'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('esr', '28.0a2', 'osx', 'en-US', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-esr-latest-ssl'),
                           ('os', 'osx'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('esr', '28.0a2', 'linux', 'en-US', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-esr-latest-ssl'),
                           ('os', 'linux'),
                           ('lang', 'en-US')])
     url = firefox_desktop.get_download_url('esr', '28.0a2', 'linux64', 'en-US', True)
     self.assertListEqual(parse_qsl(urlparse(url).query),
                          [('product', 'firefox-esr-latest-ssl'),
                           ('os', 'linux64'),
                           ('lang', 'en-US')])