HEX

File: //home/arjun/projects/env/lib/python3.10/site-packages/botocore/__pycache__/parsers.cpython-310.pyc
o

*we'��@szdZddlZddlZddlZddlZddlZddlmZm	Z	ddl
mZmZddl
mZmZmZmZe�e�ZeZGdd�d�Zdd	�Zd
d�ZGdd
�d
e�ZGdd�d�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Z Gdd�de e�Z!Gdd�de e�Z"Gdd�de�Z#Gd d!�d!e�Z$Gd"d#�d#e$e�Z%Gd$d%�d%e$e�Z&eee#e%e&d&�Z'dS)'a�Response parsers for the various protocol types.

The module contains classes that can take an HTTP response, and given
an output shape, parse the response into a dict according to the
rules in the output shape.

There are many similarities amongst the different protocols with regard
to response parsing, and the code is structured in a way to avoid
code duplication when possible.  The diagram below is a diagram
showing the inheritance hierarchy of the response classes.

::



                                 +--------------+
                                 |ResponseParser|
                                 +--------------+
                                    ^    ^    ^
               +--------------------+    |    +-------------------+
               |                         |                        |
    +----------+----------+       +------+-------+        +-------+------+
    |BaseXMLResponseParser|       |BaseRestParser|        |BaseJSONParser|
    +---------------------+       +--------------+        +--------------+
              ^         ^          ^           ^           ^        ^
              |         |          |           |           |        |
              |         |          |           |           |        |
              |        ++----------+-+       +-+-----------++       |
              |        |RestXMLParser|       |RestJSONParser|       |
        +-----+-----+  +-------------+       +--------------+  +----+-----+
        |QueryParser|                                          |JSONParser|
        +-----------+                                          +----------+


The diagram above shows that there is a base class, ``ResponseParser`` that
contains logic that is similar amongst all the different protocols (``query``,
``json``, ``rest-json``, ``rest-xml``).  Amongst the various services there
is shared logic that can be grouped several ways:

* The ``query`` and ``rest-xml`` both have XML bodies that are parsed in the
  same way.
* The ``json`` and ``rest-json`` protocols both have JSON bodies that are
  parsed in the same way.
* The ``rest-json`` and ``rest-xml`` protocols have additional attributes
  besides body parameters that are parsed the same (headers, query string,
  status code).

This is reflected in the class diagram above.  The ``BaseXMLResponseParser``
and the BaseJSONParser contain logic for parsing the XML/JSON body,
and the BaseRestParser contains logic for parsing out attributes that
come from other parts of the HTTP response.  Classes like the
``RestXMLParser`` inherit from the ``BaseXMLResponseParser`` to get the
XML body parsing logic and the ``BaseRestParser`` to get the HTTP
header/status code/query string parsing.

Additionally, there are event stream parsers that are used by the other parsers
to wrap streaming bodies that represent a stream of events. The
BaseEventStreamParser extends from ResponseParser and defines the logic for
parsing values from the headers and payload of a message from the underlying
binary encoding protocol. Currently, event streams support parsing bodies
encoded as JSON and XML through the following hierarchy.


                                  +--------------+
                                  |ResponseParser|
                                  +--------------+
                                    ^    ^    ^
               +--------------------+    |    +------------------+
               |                         |                       |
    +----------+----------+   +----------+----------+    +-------+------+
    |BaseXMLResponseParser|   |BaseEventStreamParser|    |BaseJSONParser|
    +---------------------+   +---------------------+    +--------------+
                     ^                ^        ^                 ^
                     |                |        |                 |
                     |                |        |                 |
                   +-+----------------+-+    +-+-----------------+-+
                   |EventStreamXMLParser|    |EventStreamJSONParser|
                   +--------------------+    +---------------------+

Return Values
=============

Each call to ``parse()`` returns a dict has this form::

    Standard Response

    {
      "ResponseMetadata": {"RequestId": <requestid>}
      <response keys>
    }

    Error response

    {
      "ResponseMetadata": {"RequestId": <requestid>}
      "Error": {
        "Code": <string>,
        "Message": <string>,
        "Type": <string>,
        <additional keys>
      }
    }

�N)�ETree�
XMLParseError)�EventStream�NoInitialResponseError)�is_json_value_header�lowercase_dict�merge_dicts�parse_timestampc@s$eZdZdd�Zdd�Zdd�ZdS)�ResponseParserFactorycCs
i|_dS�N)�	_defaults)�self�r�I/home/arjun/projects/env/lib/python3.10/site-packages/botocore/parsers.py�__init__��
zResponseParserFactory.__init__cKs|j�|�dS)aOSet default arguments when a parser instance is created.

        You can specify any kwargs that are allowed by a ResponseParser
        class.  There are currently two arguments:

            * timestamp_parser - A callable that can parse a timestamp string
            * blob_parser - A callable that can parse a blob type

        N)r�update)r
�kwargsrrr�set_parser_defaults�s
z)ResponseParserFactory.set_parser_defaultscCst|}|di|j��S)Nr)�PROTOCOL_PARSERSr)r
�
protocol_name�
parser_clsrrr�
create_parser�sz#ResponseParserFactory.create_parserN)�__name__�
__module__�__qualname__rrrrrrrr
�sr
cCst��|�Sr)r
r)�protocolrrrr��rcs�fdd�}|S)Ncs.t|d�r|j}|durd}n|}�|||�S)N�text�)�hasattrr)r
�shape�node_or_stringr��funcrr�_get_text_content�s
�z(_text_content.<locals>._get_text_contentr)r$r%rr#r�
_text_content�sr&c@seZdZdS)�ResponseParserErrorN)rrrrrrrr'�sr'c@s�eZdZdZdZdZd&dd�Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�ZdS)'�ResponseParseraoBase class for response parsing.

    This class represents the interface that all ResponseParsers for the
    various protocols must implement.

    This class will take an HTTP response and a model shape and parse the
    HTTP response into a dictionary.

    There is a single public method exposed: ``parse``.  See the ``parse``
    docstring for more info.

    zutf-8NcCsL|durt}||_|dur|j}||_d|_|jdur$|�||�|_dSdSr)�DEFAULT_TIMESTAMP_PARSER�_timestamp_parser�_default_blob_parser�_blob_parser�_event_stream_parser�EVENT_STREAM_PARSER_CLS�r
�timestamp_parser�blob_parserrrrr�s

��zResponseParser.__init__cCs
t�|�Sr)�base64�	b64decode�r
�valuerrrr+�s
z#ResponseParser._default_blob_parsercCs�t�d|d�t�d|d�|ddkr5|�|�r!|�|�}n|�|�r.|�||�}|S|�||�}n|�||�}|rE|j�	d�rE|St
|t�rj|�	di�}|d|d	<|d}t|�|d
<||d<|�
||�|S)a>Parse the HTTP response given a shape.

        :param response: The HTTP response dictionary.  This is a dictionary
            that represents the HTTP request.  The dictionary must have the
            following keys, ``body``, ``headers``, and ``status_code``.

        :param shape: The model shape describing the expected output.
        :return: Returns a dictionary representing the parsed response
            described by the model.  In addition to the shape described from
            the model, each response will also have a ``ResponseMetadata``
            which contains metadata about the response, which contains at least
            two keys containing ``RequestId`` and ``HTTPStatusCode``.  Some
            responses may populate additional keys, but ``RequestId`` will
            always be present.

        zResponse headers: %r�headerszResponse body:
%r�body�status_codei-�eventstream�ResponseMetadata�HTTPStatusCode�HTTPHeaders)�LOG�debug�_is_generic_error_response�_do_generic_error_parse�_is_modeled_error_shape�_do_modeled_error_parse�_do_error_parse�	_do_parse�
serialization�get�
isinstance�dictr�_add_checksum_response_metadata)r
�responser!�parsed�response_metadatar6rrr�parse�s(


zResponseParser.parsecCs2|�di��di�}|�d�}|r||d<dSdS)N�context�checksum�response_algorithm�ChecksumAlgorithm�rF)r
rJrL�checksum_context�	algorithmrrrrIs

�z.ResponseParser._add_checksum_response_metadatacCs|duo
|j�dd�S)N�	exceptionF)�metadatarF)r
r!rrrrAsz&ResponseParser._is_modeled_error_shapecCsD|ddkr d|vs|ddurdS|d��}|�d�p|SdS)Nr8i�r7Ts<html>)�strip�
startswith)r
rJr7rrrr?s�z)ResponseParser._is_generic_error_responsecCs2t�d�t|d�tjj�|dd�d�id�S)NzlReceived a non protocol specific error response from the service, unable to populate error code and message.r8r��Code�Message��Errorr:)r=r>�str�http�client�	responsesrF�r
rJrrrr@,s�
���z&ResponseParser._do_generic_error_parsecCstd|jj��)Nz%s._do_parse��NotImplementedError�	__class__r�r
rJr!rrrrD=�zResponseParser._do_parsecC�t|jj�d���)Nz._do_error_parsercrfrrrrC@szResponseParser._do_error_parsecCrh)Nz._do_modeled_error_parserc)r
rJr!rKrrrrBCs�z&ResponseParser._do_modeled_error_parsecCs t|d|j��|j�}|||�S)N�_handle_)�getattr�	type_name�_default_handle)r
r!�node�handlerrrr�_parse_shapeHs�
zResponseParser._parse_shapecCs*g}|j}|D]}|�|�||��q|Sr)�member�appendro)r
r!rmrK�member_shape�itemrrr�_handle_listNs
zResponseParser._handle_listcC�|Srr�r
r!r5rrrrlWszResponseParser._default_handlecCs&|j}|d�d�}t|d|||�S)NrN�operation_namer7)r-rFr)r
rJr!�parser�namerrr�_create_event_streamZsz#ResponseParser._create_event_streamcCst|�dS�Nr)�listr4rrr�_get_first_key_rzResponseParser._get_first_keycCsf|jr1|��}|�dd�t|�dkrd}t||j��|�|�}||jvr1d}t�	||�dSdS)N�__type�zCInvalid service response: %s must have one and only one member set.zqReceived a tagged union response with member unknown to client: %s. Please upgrade SDK for full response support.TF)
�is_tagged_union�copy�pop�lenr'ryr}�membersr=�info)r
r!r5�
cleaned_value�	error_msg�tag�msgrrr� _has_unknown_tagged_union_memberbs�

�z/ResponseParser._has_unknown_tagged_union_membercCsdd|iiS)N�SDK_UNKNOWN_MEMBERryr)r
r�rrr�#_handle_unknown_tagged_union_memberwrz2ResponseParser._handle_unknown_tagged_union_member�NN)rrr�__doc__�DEFAULT_ENCODINGr.rr+rMrIrAr?r@rDrCrBrortrlrzr}r�r�rrrrr(�s*

1	r(cs�eZdZd"�fdd�	Zdd�Zdd�Z�fdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Ze
dd��Ze
dd��Ze
dd��Ze
dd��Ze
dd��Ze
d d!��ZeZeZeZ�ZS)#�BaseXMLResponseParserNcst��||�t�d�|_dS)Nz{.*})�superr�re�compile�
_namespace_rer/�rerrr|szBaseXMLResponseParser.__init__c
Cs�i}|j}|j}|j�d�pd}|j�d�pd}|j�d�r&t|t�s&|g}|D]+}|D]"}	|�|	�}
|
|kr>|�||	�}q,|
|krI|�||	�}q,td|
��|||<q(|S)Nry�keyr5�	flattenedzUnknown tag: %s)	r�r5rErFrGr|�	_node_tagror')
r
r!rmrK�	key_shape�value_shape�key_location_name�value_location_name�keyval_node�single_pair�tag_name�key_name�val_namerrr�_handle_map�s"

z!BaseXMLResponseParser._handle_mapcCs|j�d|j�S�Nr)r��subr�)r
rmrrrr��rgzBaseXMLResponseParser._node_tagcs*|j�d�rt|t�s|g}t��||�S)Nr�)rErFrGr|r�rt)r
r!rmr�rrrt�sz"BaseXMLResponseParser._handle_listcCsi}|j}|j�dd�r|�|�}|�|�}|�||�r&|�|�}|�|�S|D]]}||}d|jvs9|j�d�r:q(|�	||�}	|�|	�}
|
durR|�
||
�||<q(|j�d�r�i}|jd}|j��D]\}
}|j
�|�d�dd|
�}|||<qd||vr�||||<q(|S)	NrUF�location�eventheader�xmlAttributery�:r)r�rVrF�_get_error_root�_build_name_to_xml_noder�r}r�rE�_member_key_namero�attrib�itemsr�r��split)r
r!rmrKr��xml_dictr��member_namerr�xml_name�member_node�attribs�
location_namer�r5�new_keyrrr�_handle_structure�s@





�

�
�
�z'BaseXMLResponseParser._handle_structurecCs2|�|�dkr|D]
}|�|�dkr|Sq	|S)N�
ErrorResponser]�r�)r
�
original_root�childrrrr��s�z%BaseXMLResponseParser._get_error_rootcCsL|jdkr|j�d�r|jj�d�}|dur|S|j�d�}|dur$|S|S)Nr|r�ry)rkrErFrp)r
r!r��list_member_serialized_name�serialized_namerrrr��s�z&BaseXMLResponseParser._member_key_namecCstt|t�r|�|d�Si}|D]'}|�|�}||vr3t||t�r*||�|�q|||g||<q|||<q|Sr{)rGr|r�r�rq)r
�parent_noder�rsr�rrrr��s


z-BaseXMLResponseParser._build_name_to_xml_nodec
CsVztjt��|jd�}|�|�|��}W|Sty*}ztd||f��d}~ww)N)�target�encodingzTUnable to parse response (%s), invalid XML received. Further retries may succeed:
%s)r�	XMLParser�TreeBuilderr��feed�closerr')r
�
xml_stringrx�root�errr�_parse_xml_string_to_dom�s
�

�����z.BaseXMLResponseParser._parse_xml_string_to_domcCsB|��D]\}}t|�r|�|�}|�|�||<q|j||<q|Sr)r�r|r��_replace_nodesr)r
rKr�r5�sub_dictrrrr�s
z$BaseXMLResponseParser._replace_nodescCs|dkrdSdS)N�trueTFr�r
r!rrrr�_handle_booleansz%BaseXMLResponseParser._handle_booleancC�t|�Sr)�floatr�rrr�
_handle_float�z#BaseXMLResponseParser._handle_floatcC�
|�|�Sr�r*r�rrr�_handle_timestamp�
z'BaseXMLResponseParser._handle_timestampcCr�r��intr�rrr�_handle_integerr�z%BaseXMLResponseParser._handle_integercCrurrr�rrr�_handle_stringsz$BaseXMLResponseParser._handle_stringcCr�r�r,r�rrr�_handle_blob#r�z"BaseXMLResponseParser._handle_blobr�)rrrrr�r�rtr�r�r�r�r�r�r&r�r�r�r�r�r��_handle_character�_handle_double�_handle_long�
__classcell__rrr�rr�{s4
$	





r�c@s>eZdZdd�Zdd�Zdd�Zddd	�Zd
d�Zdd
�ZdS)�QueryParsercCs\|d}|�|�}|�|�}|�|�d|vr|�|�d��d|vr,d|�d�i|d<|S)Nr7�Errors�	RequestIdr:)r�r�r�rr�)r
rJr!�xml_contentsr�rKrrrrC-s


zQueryParser._do_error_parsecC�|j||dd�S)NF��inject_metadata��_parse_body_as_xmlrfrrrrB=rgz#QueryParser._do_modeled_error_parsecCr�)NTr�r�rfrrrrD@rgzQueryParser._do_parseTcCs^|d}|�|�}i}|dur%|}d|jvr|�|jd|�}|�||�}|r-|�||�|S)Nr7�
resultWrapper)r�rE�_find_result_wrapped_shapero�_inject_response_metadata)r
rJr!r�r�r�rK�startrrrr�Cs


�zQueryParser._parse_body_as_xmlcCs|�|�}||Sr)r�)r
�element_name�
xml_root_node�mappingrrrr�Rs
z&QueryParser._find_result_wrapped_shapecCsR|�|�}|�d�}|dur'|�|�}|��D]	\}}|j||<q||d<dSdS�Nr:)r�rFr�r)r
rm�inject_intor��
child_node�sub_mappingr�r5rrrr�Vs


�z%QueryParser._inject_response_metadataN)T)	rrrrCrBrDr�r�r�rrrrr�,s
r�cs,eZdZdd�Z�fdd�Zdd�Z�ZS)�EC2QueryParsercCs2|�|�}|�d�}|durd|ji|d<dSdS)N�	requestIdr�r:)r�rFr)r
rmr�r�r�rrrr�as


�z(EC2QueryParser._inject_response_metadatacs,t��||�}d|vrd|�d�i|d<|S)N�	RequestIDr�r:)r�rCr�)r
rJr!�originalr�rrrCgs


�zEC2QueryParser._do_error_parsecCs@|D]}|�|�dkr|D]}|�|�dkr|Sq
q|S)Nr�r]r�)r
r�r��errors_childrrrr�{s��zEC2QueryParser._get_error_root)rrrr�rCr�r�rrr�rr�`sr�c@sLeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dS)�BaseJSONParserc
Cs�i}|jr	|}|S|j}|durdSi}|�||�r$|�|�}|�|�S|D] }||}|j�d|�}|�|�}	|	durF|�|||	�||<q&|S)Nry)�is_document_typer�r�r}r�rErFro)
r
r!r5�final_parsed�
member_shapesr�r�rr�	json_name�	raw_valuerrrr��s*�


��z BaseJSONParser._handle_structurec	CsFi}|j}|j}|��D]\}}|�||�}|�||�}|||<q|Sr)r�r5r�ro)	r
r!r5rKr�r�r��
actual_key�actual_valuerrrr��s
zBaseJSONParser._handle_mapcCr�rr�rvrrrr��rzBaseJSONParser._handle_blobcCr�rr�rvrrrr��rz BaseJSONParser._handle_timestampcCs�|�|d�}ddd�id�}|d}|�d|�dd��|dd<|�d	�}|�d
|o.t|��}|durQd|vr@|�dd�d}d
|vrK|�|||�}||dd<|�||d�|S)Nr7r�r[rZr\r6�messager[r]r8r~�#r�x-amzn-query-errorrZ)�_parse_body_as_jsonrFr^�rsplit� _do_query_compatible_error_parser�)r
rJr!r7�errorr6�
response_code�coderrrrC�s$	�
�zBaseJSONParser._do_error_parsecCsN|d}|�d�}t|�dkr%|dr%||dd<|d|dd<|dS|S)	z�
        Error response may contain an x-amzn-query-error header to translate
        errors codes from former `query` services into `json`. We use this to
        do our lookup in the errorfactory for modeled errors.
        r�;�rr]�QueryErrorCoder�Type)r�r�)r
r	r6r�query_error�query_error_componentsrrrr�s
z/BaseJSONParser._do_query_compatible_error_parsecCs$d|vr|d|�di�d<dSdS)N�x-amzn-requestidr:r�)�
setdefault)r
rKr6rrrr��s
��z(BaseJSONParser._inject_response_metadatacCs@|siS|�|j�}zt�|�}|WStyd|iYSw)Nr)�decoder��json�loads�
ValueError)r
�
body_contentsr7�original_parsedrrrr�s
�z"BaseJSONParser._parse_body_as_jsonN)rrrr�r�r�r�rCrr�rrrrrr��s
"r�c@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�BaseEventStreamParsercCsji}|j�d�r!|d�d�}|j�|�}|r|�||�||<|S|�|||j|�|�|||j|�|S)Nr9r6z:event-type)rErFr�rD�_parse_non_payload_attrs�_parse_payload)r
rJr!r��
event_type�event_shaperrrrD�s��
�zBaseEventStreamParser._do_parsec	Cs�|d�d�}|j�|�}|dur/|�|d�}|�||�}d||�d|�dd��d�i}|Sd|d�d	d�|d�d
d�d�i}|S)Nr6z:exception-typer7r]r[rrrYz:error-codez:error-message)rFr��_initial_body_parsero)r
rJr!�exception_type�exception_shaperr7rrrrrCs"��
���z%BaseEventStreamParser._do_error_parsecCs�|j�d�rS|D]6}||}|j�d�r>|d}|jdkr |}n|jdkr,|�|j�}n|�|�}	|�||	�}|||<dSq|�|d�}
|�||
�}|�|�dSdS)N�event�eventpayloadr7�blob�string)rErFrkrr�rror)r
rJr!r�r�ryrrr7�parsed_body�	raw_parser�body_parsedrrrrs(


���z$BaseEventStreamParser._parse_payloadc	CsZ|d}|D]$}||}|j�d�r*||vr*||}|jdkr&|�|d�}|||<qdS)Nr6r��	timestampg@�@)rErFrkr*)	r
rJr!r�r�r6ryrrr5rrrr.s
��z.BaseEventStreamParser._parse_non_payload_attrscC�td���Nr�rd�r
rrrrr=�z)BaseEventStreamParser._initial_body_parseN)rrrrDrCrrrrrrrr�src@�eZdZdd�ZdS)�EventStreamJSONParsercC�
|�|�Sr�rr+rrrrFrz)EventStreamJSONParser._initial_body_parseN�rrrrrrrrr.E�r.c@r-)�EventStreamXMLParsercC�|st�d�S|�|�Sr��r�Elementr��r
r�rrrrK�

z(EventStreamXMLParser._initial_body_parseNr1rrrrr3Jr2r3c@s2eZdZeZ	dd�Zdd�Zdd�Zdd�Zd	S)
�
JSONParsercCsJi}|dur|j}|r|�|||�}n|�|d|�}|�||d�|S)Nr7r6)�event_stream_name�_handle_event_stream�_handle_json_bodyr�)r
rJr!rK�
event_namerrrrDVszJSONParser._do_parsecCs|�|d|�S)Nr7)r<rfrrrrBargz"JSONParser._do_modeled_error_parsec	CsX|j|}|�||�}z|��}Wn
tyd}t|��w|�|j|�}|||<|S)Nz,First event was not of type initial-response)r�rz�get_initial_responserr'r<�payload)	r
rJr!r=�event_stream_shape�event_streamr r�rKrrrr;ds
�zJSONParser._handle_event_streamcCs|�|�}|�||�Sr)rro)r
�raw_bodyr!�parsed_jsonrrrr<ps
zJSONParser._handle_json_bodyN)	rrrr.r.rDrBr;r<rrrrr9Qsr9csdeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Z�fdd�Z�Z
S)�BaseRestParsercCs$i}|�|�|d<|�|||�|Sr�)�_populate_response_metadata�_add_modeled_parse�r
rJr!r�rrrrDys�zBaseRestParser._do_parsecCs6|dur|S|j}|�||||�|�||||�dSr)r�rr)r
rJr!r�r�rrrrF�s�z!BaseRestParser._add_modeled_parsecCsi}|�|||�|Sr)rFrGrrrrB�sz&BaseRestParser._do_modeled_error_parsecCsLi}|d}d|vr|d|d<|Sd|vr$|d|d<|�dd�|d<|S)Nr6rr��x-amz-request-id�
x-amz-id-2r�HostIdrR)r
rJrVr6rrrrE�s�z*BaseRestParser._populate_response_metadatac
Cs�d|jvrK|jd}||}|j�d�r |�||�}|||<dS|jdvr:|d}t|t�r4|�|j�}|||<dS|�|d�}|�	||�||<dS|�|d�}|�	||�}	|�
|	�dS)Nr?r9)r#r"r7)rErFrzrkrG�bytesrr�rror)
r
rJr!r�r��payload_member_name�
body_shaper7rr&rrrr�s$



�zBaseRestParser._parse_payloadc
Cs�|d}|D]F}||}|j�d�}|durq|dkr&|�||d�||<q|dkr3|�||�||<q|dkrL|j�d|�}	|	|vrL|�|||	�||<qdS)Nr6r��
statusCoder8�headerry)rErFro�_parse_header_map)
r
rJr!r�r�r6ryrrr��header_namerrrr�s,
�
����z'BaseRestParser._parse_non_payload_attrscCsNi}|j�dd���}|D]}|���|�r$|t|�d�}||||<q
|S)Nryr)rErF�lowerrXr�)r
r!r6rK�prefixrQryrrrrP�s�z BaseRestParser._parse_header_mapcCr(r)r*r+rrrr�r,z"BaseRestParser._initial_body_parsecCs,|}t|�rt�|��|j�}t�|�}|Sr)rr2r3rr�rr)r
r!r5rK�decodedrrrr��s

zBaseRestParser._handle_stringcs@|j�d�}|dkrt|t�sdd�|�d�D�}t��||�S)Nr�rOcSsg|]}|���qSr)rW)�.0r�rrr�
<listcomp>�sz/BaseRestParser._handle_list.<locals>.<listcomp>�,)rErFrGr|r�r�rt)r
r!rmr�r�rrrt�szBaseRestParser._handle_list)rrrrDrFrBrErrrPrr�rtr�rrr�rrDxs	

rDcs<eZdZeZdd�Z�fdd�Zdd�Zdd�ZeZ	�Z
S)	�RestJSONParsercCr/rr0r+rrrr�rz"RestJSONParser._initial_body_parsecst��||�}|�||�|Sr)r�rC�_inject_error_code)r
rJr!rr�rrrC�szRestJSONParser._do_error_parsecCsx|�|d�}d|dvr"|dd}|�d�d}||dd<dSd|vs*d|vr:|�d|�dd	��|dd<dSdS)
Nr7zx-amzn-errortyper6r�rr]rZr	r)rr�rF)r
rrJr7r	rrrrY�s �z!RestJSONParser._inject_error_codecCr�rr�rvrrrr�szRestJSONParser._handle_integer)rrrr.r.rrCrYr�r�r�rrr�rrX�s
rXcsDeZdZeZdd�Zdd�Zdd�Zdd�Ze	�fd	d
��Z
�ZS)�
RestXMLParsercCr4r�r5r7rrrrr8z!RestXMLParser._initial_body_parsecCs@|drz|�|�WStytjddd�Ynw|�|�S)Nr7z2Exception caught when parsing error response body:T)�exc_info)�_parse_error_from_bodyr'r=r>�_parse_error_from_http_statusrfrrrrCs
��
zRestXMLParser._do_error_parsecCsFt|d�tjj�|dd�d�|d�dd�|d�dd�d�d�S)	Nr8rrYr6rHrI)r�rJr\)r^r_r`rarFrbrrrr]1s
����z+RestXMLParser._parse_error_from_http_statuscCs�|d}|�|�}|�|�}|�|�|jdkr.|�|�}|�dd�|�dd�||d�Sd|vr;d|�d�i|d<dddd�i}t||�|S)	Nr7r]r�rrJr\r:r)r�r�r�r�rEr�r)r
rJr�r�rKrV�defaultrrrr\?s






z$RestXMLParser._parse_error_from_bodycst��||�}|Sr)r�r�r�r�rrr�VszRestXMLParser._handle_string)rrrr3r.rrCr]r\r&r�r�rrr�rrZsrZ)�ec2�queryrz	rest-jsonzrest-xml)(r�r2�http.clientr_r�loggingr��botocore.compatrr�botocore.eventstreamrr�botocore.utilsrrrr	�	getLoggerrr=r)r
rr&�	Exceptionr'r(r�r�r�r�rr.r3r9rDrXrZrrrrr�<module>sFh
A24$nS'xO
�