Python urls.url_decode_stream方法代码示例

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def request_authentication(
        self, redirect_url: str
    ) -> AuthenticationContinuation:
        response = self.request('POST', self.REQUEST_TOKEN_URL.format(self))
        request_token = url_decode_stream(response)
        response.close()
        return AuthenticationContinuation(
            self.AUTHORIZE_URL.format(self) + '?' + url_encode({
                'oauth_token': request_token['oauth_token'],
                'oauth_callback': redirect_url
            }),
            (request_token['oauth_token'], request_token['oauth_token_secret'])
        ) 

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def authenticate(self,
                     state,
                     requested_redirect_url: str,
                     wsgi_environ: Mapping[str, object]) -> Identity:
        logger = logging.getLogger(__name__ + '.StashTeam.authenticate')
        logger.debug('state = %r', state)
        try:
            oauth_token, oauth_token_secret = state
        except ValueError:
            raise AuthenticationError()
        req = Request(wsgi_environ, populate_request=False, shallow=True)
        args = cast(ImmutableMultiDict, req.args)
        logger.debug('req.args = %r', args)
        if args.get('oauth_token') != oauth_token:
            raise AuthenticationError()
        response = self.request(
            'POST', self.ACCESS_TOKEN_URL.format(self),
            resource_owner_key=oauth_token,
            resource_owner_secret=oauth_token_secret
        )
        access_token = url_decode_stream(response)
        logger.debug('access_token = %r', access_token)
        response.close()
        response = self.request(
            'GET', self.USER_URL.format(self),
            resource_owner_key=access_token['oauth_token'],
            resource_owner_secret=access_token['oauth_token_secret']
        )
        whoami = response.read().decode('utf-8')
        return Identity(
            type(self),
            self.USER_PROFILE_URL.format(self, whoami),
            (access_token['oauth_token'], access_token['oauth_token_secret'])
        ) 

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def _parse_urlencoded(self, stream, mimetype, content_length, options):
        if self.max_form_memory_size is not None and \
           content_length is not None and \
           content_length > self.max_form_memory_size:
            raise exceptions.RequestEntityTooLarge()
        form = url_decode_stream(stream, self.charset,
                                 errors=self.errors, cls=self.cls)
        return stream, form, self.cls()

    #: mapping of mimetypes to parsing functions 

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def test_streamed_url_decoding(self):
        item1 = u'a' * 100000
        item2 = u'b' * 400
        string = ('a=%s&b=%s&c=%s' % (item1, item2, item2)).encode('ascii')
        gen = urls.url_decode_stream(BytesIO(string), limit=len(string),
                                     return_iterator=True)
        self.assert_strict_equal(next(gen), ('a', item1))
        self.assert_strict_equal(next(gen), ('b', item2))
        self.assert_strict_equal(next(gen), ('c', item2))
        self.assert_raises(StopIteration, lambda: next(gen)) 

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def test_stream_decoding_string_fails(self):
        self.assert_raises(TypeError, urls.url_decode_stream, 'testing') 

# 需要导入模块: from werkzeug import urls [as 别名]
# 或者: from werkzeug.urls import url_decode_stream [as 别名]
def authenticate(
        self,
        state,
        requested_redirect_url: str,
        wsgi_environ: Mapping[str, object]
    ) -> Identity:
        logger = self.logger.getChild('authenticate')
        req = Request(wsgi_environ, populate_request=False, shallow=True)
        args = cast(ImmutableMultiDict, req.args)
        try:
            code = args['code']
            if args['state'] != state:
                raise AuthenticationError()
        except KeyError:
            raise AuthenticationError()
        data = url_encode({
            'client_id': self.client_id,
            'client_secret': self.client_secret,
            'code': code,
            'redirect_uri': requested_redirect_url,
            'grant_type': 'authorization_code',
        }).encode()
        try:
            response = urllib.request.urlopen(self.access_token_url, data)
        except urllib.error.HTTPError as e:
            logger.debug('Response of POST %s (with/ %r): %s\n%s',
                         self.access_token_url, data, e.code, e.read())
            raise
        assert isinstance(response, http.client.HTTPResponse), \
            'isinstance(response, {0.__module__}.{0.__qualname__})'.format(
                type(response))
        headers = getattr(response, 'headers')  # workaround mypy
        content_type = headers['Content-Type']
        mimetype, options = parse_options_header(content_type)
        if mimetype == 'application/x-www-form-urlencoded':
            token_data = url_decode_stream(response)
        elif mimetype == 'application/json':
            charset = options.get('charset', 'utf-8')
            token_data = json.load(
                io.TextIOWrapper(cast(IO[bytes], response), encoding=charset)
            )
        else:
            response.close()
            raise AuthenticationError(
                '{} sent unsupported content type: {}'.format(
                    self.access_token_url,
                    content_type
                )
            )
        response.close()
        identity = self.determine_identity(token_data['access_token'])
        if self.authorize(identity):
            return identity
        raise AuthenticationError(
            self.unauthorized_identity_message_format.format(
                identity=identity, team=self
            )
        )