Python Response.json方法代码示例

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
 def __init__(self, response: requests.Response) -> None:
     """
     wrap some useful information
     :param response: response we got from nessus, in which there _must_ be json with an 'error' field
     """
     assert 'error' in response.json()
     super().__init__(response.json()['error'])
     self.response = response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
    def assertHttpRespJsonFieldIsUrl(self, resp: _requests.Response, key: str):
        self.assertHttpRespJsonHasField(resp, key)

        try:
            _validation.rule.Url(resp.json()[key]).validate()
        except _validation.error.RuleError:
            if not isinstance(resp.json()[key], int):
                self._raiseHttpException("HTTP response JSON field '{}' is not a valid URL".format(key), resp=resp)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
    def _process_response(response: requests.Response, expected: list = []) -> dict:
        """
        Processes an API response. Raises an exception when appropriate.

        The exception that will be raised is MoneyBird.APIError. This exception is subclassed so implementing programs
        can easily react appropriately to different exceptions.

        The following subclasses of MoneyBird.APIError are likely to be raised:
          - MoneyBird.Unauthorized: No access to the resource or invalid authentication
          - MoneyBird.Throttled: Access (temporarily) denied, please try again
          - MoneyBird.NotFound: Resource not found, check resource path
          - MoneyBird.InvalidData: Validation errors occured while processing your input
          - MoneyBird.ServerError: Error on the server

        :param response: The response to process
        :param expected: A list of expected status codes which won't raise an exception
        :return: The useful data in the response (may be None)
        """
        responses = {
            200: None,
            201: None,
            400: MoneyBird.Unauthorized,
            401: MoneyBird.Unauthorized,
            403: MoneyBird.Throttled,
            404: MoneyBird.NotFound,
            406: MoneyBird.NotFound,
            422: MoneyBird.InvalidData,
            429: MoneyBird.Throttled,
            500: MoneyBird.ServerError,
        }

        logger.debug("API request: %s %s\n" % (response.request.method, response.request.url) +
                     "Response: %s %s" % (response.status_code, response.text))

        if response.status_code not in expected:
            if response.status_code not in responses:
                logger.error("API response contained unknown status code")
                raise MoneyBird.APIError(response, "API response contained unknown status code")
            elif responses[response.status_code] is not None:
                try:
                    description = response.json()['error']
                except (AttributeError, TypeError, KeyError, ValueError):
                    description = None
                raise responses[response.status_code](response, description)

        try:
            data = response.json()
        except ValueError:
            logger.error("API response is not JSON decodable")
            data = None

        return data

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def _read_pin_result_parser(raw_response: Response) -> dict:
    """
    Parse the raw response of reading a pin.
    @param raw_response: Raw response.
    @return: The reading.
    """
    return raw_response.json()

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
 def test_retry(self, mock_get, mock_id, mock_auth, mock_retry):
     blk = InstagramSearchByUser()
     self.configure_block(blk, {
         "queries": [
             "user1",
             "user2"
         ]
     })
     blk.queries = ['1', '2']
     blk._n_queries = len(blk.queries())
     resp = Response()
     resp.status_code = 400
     resp.json = Mock()
     resp.json.return_value = \
         {
             'meta': {
                 'error_type': 'WardrobeMalfunction',
                 'code': 400,
                 'error_message': "Your pants don't fit"
             }
         }
     mock_get.return_value = resp
     paging = False
     self.assertEqual(0, blk._idx)
     blk.poll(paging)
     # don't skip to next idx because we are retrying.
     self.assertEqual(0, blk._idx)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
 def test_private_user(self, mock_get, mock_id, mock_auth, mock_retry):
     blk = InstagramSearchByUser()
     self.configure_block(blk, {
         "queries": [
             "user1",
             "user2"
         ]
     })
     blk.queries = ['1', '2']
     blk._n_queries = len(blk.queries())
     resp = Response()
     resp.status_code = 400
     resp.json = Mock()
     resp.json.return_value = \
         {
             'meta': {
                 'error_type': 'APINotAllowedError',
                 'code': 400,
                 'error_message': 'you cannot view this resource'
             }
         }
     mock_get.return_value = resp
     paging = False
     self.assertEqual(0, blk._idx)
     blk.poll(paging)
     # skip to next idx because we are not retrying.
     self.assertEqual(1, blk._idx)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
    def test_get_token_with_scope(self, get_token):
        the_response = Response()
        the_response.status_code = 200
        the_response.json = MagicMock(return_value={'access_token': 'foobar'})
        get_token.return_value = the_response

        block = OAuthBlock()
        self.configure_block(block, {})
        token = block.get_access_token(
            'user', 'pass',
            scope='my-scope',
            addl_params={
                'extra': 'value'
            })

        self.assertEqual(token['access_token'], 'foobar')
        self.assertEqual(block.get_access_token_headers(), {
            'Authorization': 'Bearer foobar'
        })

        get_token.assert_called_once_with(
            'http://oauthbase/token',
            data={
                'username': 'user',
                'password': 'pass',
                'scope': 'my-scope',
                'grant_type': 'password',
                'extra': 'value'
            })

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def parse_http_response(http_response: HttpResponse) -> 'environ.Response':
    """
    Returns a Cauldron response object parsed from the serialized JSON data
    specified in the http_response argument. If the response doesn't contain
    valid Cauldron response data, an error Cauldron response object is
    returned instead.

    :param http_response:
        The response object from an http request that contains a JSON
        serialized Cauldron response object as its body
    :return:
        The Cauldron response object for the given http response
    """
    try:
        response = environ.Response.deserialize(http_response.json())
    except Exception as error:
        response = environ.Response().fail(
            code='INVALID_REMOTE_RESPONSE',
            error=error,
            message='Invalid HTTP response from remote connection'
        ).console(
            whitespace=1
        ).response

    response.http_response = http_response
    return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
    def test_token(self, mock_head, mock_post, mock_service_creds):

        # mock out the token request response
        the_response = Response()
        the_response.status_code = 200
        the_response.json = MagicMock(return_value={'access_token': 'foobar'})
        mock_post.return_value = the_response

        block = OAuthBlock()
        self.configure_block(block, {
            "key_config_file": "tests/KEY_FILE_GOES_HERE.json"
        })

        token = block.get_access_token(
            'https://www.googleapis.com/auth/analytics.readonly')

        self.assertEqual(token['access_token'], 'foobar')

        # Oauth2ServiceAccount.get_access_token is mocked, so
        # Oauth2ServiceAccount.parse_token_from_response(r) is never called,
        # and self._oauth_token is never assigned.
        # Need to assign it here before checking block.get_access_token_headers
        block._oauth_token = {'access_token': 'foobar'}
        self.assertEqual(block.get_access_token_headers(), {
            'Authorization': 'Bearer foobar'
        })

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def response_to_data(response: Response):
    try:
        return response.json()
    except Exception as x:
        raise FormatError("Invalid format, could not parse JSON. Error: {}, status={}, text={}".format(
            x, response.status_code, response.text
        )) from x

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def get_acacess_token_app(tenant_id,client_id,client_secret,resource):
    initialise()
    
    url = "https://login.windows.net/" + tenant_id + "/oauth2/token"        
    
    body_data = "&grant_type=client_credentials&resource="+ resource +"&client_id="+ client_id + "&client_secret="+  urllib.quote_plus(client_secret)
    
    headers = {"Content-Type":"application/x-www-form-urlencoded"}
    req = Request(method="POST",url=url,data=body_data)
    req_prepped = req.prepare()
    s = Session()
    res = Response()
    res = s.send(req_prepped)
    access_token_det = {}
    if (res.status_code == 200):
        responseJSON = json.loads(res.content)
        access_token_det["details"]= responseJSON["access_token"]
        access_token_det["status"]="1"
        access_token_det["exp_time"]=responseJSON["expires_in"]
        access_token_det["exp_date"]=responseJSON["expires_on"]
        access_token_det["accessDetails"]=responseJSON
    else:
        access_token_det["details"]= str(res.status_code) + str(res.json())
        access_token_det["status"]="0"
    return access_token_det

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def _process_response(response: requests.Response, extra: dict=None, obj: object=None):
    extra = extra or {}
    extra.update({
        'status_code': response.status_code,
        'url': response.request.url.split('?')[0],
    })

    if hasattr(response.request, 'data'):
        extra['data'] = response.request.data

    if hasattr(response.request, 'params'):
        extra['params'] = response.request.params

    if obj:
        if hasattr(obj, 'id'):
            extra['id'] = obj.id
        if hasattr(obj, 'vox_id'):
            extra['vox_id'] = obj.vox_id

    if response.status_code != 200:
        extra['response_text'] = response.text
        logger.error('API request error', extra=extra)
        raise VoxApiException('Got status code: %s.' % response.status_code, response=response)

    result = response.json()
    extra['result'] = result

    if 'error' in result:
        logger.error('API request error', extra=extra)
        raise VoxApiException('Upload error: %s.' % result['error']['msg'], response=response)

    logger.debug('API request', extra=extra)
    return result

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
 def stub(url):
     response = Response()
     response._content = json
     response.url = url
     response.status_code = status_code
     response.json = json_loads_stub(json)
     return response

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
 async def did_receive_response(
     self,
     response: requests.Response,
     request: Request
 ) -> typing.Any:
     response.raise_for_status()
     return response.json(object_hook=self.convert_to_object)

# 需要导入模块: from requests import Response [as 别名]
# 或者: from requests.Response import json [as 别名]
def json_or_none(response:r.Response) -> Optional[Mapping[str, str]]:
    """
    Returns a valid JSON, when the response if not a valid JSON, returns `None`.
    """
    try:
        return response.json()
    except ValueError:
        return None