HEX
Server: nginx/1.24.0
System: Linux webserver 6.8.0-85-generic #85-Ubuntu SMP PREEMPT_DYNAMIC Thu Sep 18 15:26:59 UTC 2025 x86_64
User: wpuser (1002)
PHP: 8.3.6
Disabled: NONE
Upload Files
File: //lib/python3/dist-packages/botocore/__pycache__/parsers.cpython-312.pyc
�

P��e'�����dZddlZddlZddlZddlZddlZddlmZm	Z	ddl
mZmZddl
mZmZmZmZej$e�ZeZGd�d�Zd�Zd	�ZGd
�de�ZGd�d
�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�Z Gd�de e�Z!Gd�de e�Z"Gd�de�Z#Gd�de�Z$Gd �d!e$e�Z%Gd"�d#e$e�Z&eee#e%e&d$�Z'y)%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��eZdZd�Zd�Zd�Zy)�ResponseParserFactoryc��i|_y�N)�	_defaults)�selfs �2/usr/lib/python3/dist-packages/botocore/parsers.py�__init__zResponseParserFactory.__init__�s	�����c�:�|jj|�y)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�kwargss  r�set_parser_defaultsz)ResponseParserFactory.set_parser_defaults�s��	
�����f�%rc�8�t|}|di|j��S)N�)�PROTOCOL_PARSERSr)r�
protocol_name�
parser_clss   r�
create_parserz#ResponseParserFactory.create_parser�s��%�m�4�
��+�D�N�N�+�+rN)�__name__�
__module__�__qualname__rrrrrrrr�s���
&�,rrc�4�t�j|�Sr)rr)�protocols rrr�s�� �"�0�0��:�:rc����fd�}|S)Nc�V��t|d�r|j}|�d}n|}�|||�S)N�text�)�hasattrr%)r�shape�node_or_stringr%�funcs    �r�_get_text_contentz(_text_content.<locals>._get_text_content�s8����>�6�*�!�&�&�D��|���!�D��D�%��&�&rr)r*r+s` r�
_text_contentr,�s���
'��rc��eZdZy)�ResponseParserErrorN)rrr rrrr.r.�s��rr.c��eZdZdZdZdZdd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zy)�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-8Nc��|�t}||_|�|j}||_d|_|j
�|j||�|_yyr)�DEFAULT_TIMESTAMP_PARSER�_timestamp_parser�_default_blob_parser�_blob_parser�_event_stream_parser�EVENT_STREAM_PARSER_CLS)r�timestamp_parser�blob_parsers   rrzResponseParser.__init__�s`���#�7��!1������3�3�K�'���$(��!��'�'�3�(,�(D�(D� �+�)�D�%�4rc�,�tj|�Sr)�base64�	b64decode�r�values  rr4z#ResponseParser._default_blob_parser�s������&�&rc�:�tjd|d�tjd|d�|ddk\r[|j|�r|j|�}nJ|j	|�r|j||�}|S|j
||�}n|j||�}|r|jjd�r|St|t�rD|jdi�}|d|d	<|d}t|�|d
<||d<|j||�|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_metadatar@s      r�parsezResponseParser.parse�s'��"	�	�	�(�(�9�*=�>��	�	�&���(8�9��M�"�c�)��.�.�x�8��5�5�h�?���-�-�e�4��5�5�h��F���
��-�-�h��>���^�^�H�e�4�F��U�(�(�,�,�]�;��M��f�d�#� &�
�
�+=�r� B��2:�=�2I��.�/��y�)�G�/=�g�/F��m�,�):�F�%�&��0�0��;L�M��
rc�z�|jdi�jdi�}|jd�}|r||d<yy)N�context�checksum�response_algorithm�ChecksumAlgorithm�rP)rrTrV�checksum_context�	algorithms     rrSz.ResponseParser._add_checksum_response_metadatasE��#�<�<�	�2�6�:�:�:�r�J��$�(�(�)=�>�	��5>��1�2�rc�F�|duxr|jjdd�S)N�	exceptionF)�metadatarP)rr(s  rrKz&ResponseParser._is_modeled_error_shapes#���D� �K�U�^�^�%7�%7��U�%K�Krc�z�|ddk\r3d|vs|d�y|dj�}|jd�xs|Sy)NrBi�rATs<html>)�strip�
startswith)rrTrAs   rrIz)ResponseParser._is_generic_error_responsesT���M�"�c�)��X�%��&�)9�)A���F�#�)�)�+�D��?�?�9�-�9�T��9�*rc��tjd�t|d�tjj
j
|dd�d�id�S)NzlReceived a non protocol specific error response from the service, unable to populate error code and message.rBr&��Code�Message��ErrorrD)rGrH�str�http�client�	responsesrP�rrTs  rrJz&ResponseParser._do_generic_error_parse,s[��	�	�	�
B�	
��H�]�3�4��;�;�0�0�4�4��]�+�R���!#�
�	
rc�F�td|jjz��)Nz%s._do_parse��NotImplementedError�	__class__r�rrTr(s   rrNzResponseParser._do_parse=s��!�.�4�>�>�3J�3J�"J�K�Krc�F�t|jj�d���)Nz._do_error_parserrrus   rrMzResponseParser._do_error_parse@s ��!�T�^�^�%<�%<�$=�=M�"N�O�Orc�F�t|jj�d���)Nz._do_modeled_error_parserr)rrTr(rUs    rrLz&ResponseParser._do_modeled_error_parseCs%��!��~�~�&�&�'�'?�@�
�	
rc�\�t|d|j��|j�}|||�S)N�_handle_)�getattr�	type_name�_default_handle)rr(�node�handlers    r�_parse_shapezResponseParser._parse_shapeHs4����H�U�_�_�-�.��0D�0D�
���u�d�#�#rc�r�g}|j}|D]#}|j|j||���%|Sr)�member�appendr)rr(r}rU�member_shape�items      r�_handle_listzResponseParser._handle_listNsA�����|�|���	A�D��M�M�$�+�+�L�$�?�@�	A��
rc��|Srr�rr(r>s   rr|zResponseParser._default_handleWs���rc�d�|j}|djd�}t|d|||�S)NrY�operation_namerA)r6rPr)rrTr(�parser�names     r�_create_event_streamz#ResponseParser._create_event_streamZs9���*�*���	�"�&�&�'7�8���8�F�+�U�F�D�A�Arc��t|�dS�Nr)�listr=s  r�_get_first_keyzResponseParser._get_first_key_s���E�{�1�~�rc�$�|jr�|j�}|jdd�t|�dk7rd}t	||j
z��|j
|�}||jvrd}tj||z�yy)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.r�r��membersrG�info)rr(r>�
cleaned_value�	error_msg�tag�msgs       r� _has_unknown_tagged_union_memberz/ResponseParser._has_unknown_tagged_union_memberbs���� � �!�J�J�L�M����h��-��=�!�Q�&�&��*�)�e�j�j�*@�A�A��%�%�m�4�C��%�-�-�'�(��
����s��#��rc��dd|iiS)N�SDK_UNKNOWN_MEMBERr�r)rr�s  r�#_handle_unknown_tagged_union_memberz2ResponseParser._handle_unknown_tagged_union_memberws��$�v�s�m�4�4r�NN)rrr �__doc__�DEFAULT_ENCODINGr7rr4rWrSrKrIrJrNrMrLrr�r|r�r�r�r�rrrr0r0�so�����"���'�/�b?�L�:�&
�"L�P�
�
$���B�
��*5rr0c����eZdZd�fd�	Zd�Zd�Z�fd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Ze
d��Ze
d��Ze
d
��Ze
d��Ze
d��Ze
d��ZeZeZeZ�xZS)�BaseXMLResponseParserc�Z��t�|�||�tjd�|_y)Nz{.*})�superr�re�compile�
_namespace_re)rr8r9rts   �rrzBaseXMLResponseParser.__init__|s$���
���)�;�7��Z�Z��/��rc���i}|j}|j}|jjd�xsd}|jjd�xsd}|jjd�rt	|t
�s|g}|D]\}|D]P}	|j
|	�}
|
|k(r|j||	�}�,|
|k(r|j||	�}�Dtd|
z��|<�^|S)Nr��keyr>�	flattenedzUnknown tag: %s)	r�r>rOrPrQr��	_node_tagrr.)
rr(r}rU�	key_shape�value_shape�key_location_name�value_location_name�keyval_node�single_pair�tag_name�key_name�val_names
             r�_handle_mapz!BaseXMLResponseParser._handle_map�s������I�I�	��k�k��%�3�3�7�7��?�H�5��)�7�7�;�;�F�C�N�w�����"�"�;�/�
�4��8N��6�D��
	(�K�*�
L���>�>�+�6���0�0�#�0�0��K�H�H��!4�4�#�0�0��k�J�H�-�.?�(�.J�K�K�
L� (�F�8��
	(��
rc�N�|jjd|j�S�Nr&)r��subr�)rr}s  rr�zBaseXMLResponseParser._node_tag�s���!�!�%�%�b�$�(�(�3�3rc���|jjd�rt|t�s|g}t�|�||�S)Nr�)rOrPrQr�r�r�)rr(r}rts   �rr�z"BaseXMLResponseParser._handle_list�s;������"�"�;�/�
�4��8N��6�D��w�#�E�4�0�0rc��i}|j}|jjdd�r|j|�}|j	|�}|j||�r"|j
|�}|j|�S|D]�}||}d|jvs|jjd�r�2|j||�}	|j|	�}
|
�|j||
�||<�m|jjd�s��i}|jd}|jj�D];\}
}|jj|jd�ddz|
�}|||<�=||vs��||||<��|S)	NraF�location�eventheader�xmlAttributer��:r)r�rbrP�_get_error_root�_build_name_to_xml_noder�r�r�rO�_member_key_namer�attrib�itemsr�r��split)rr(r}rUr��xml_dictr��member_namer��xml_name�member_node�attribs�
location_namer�r>�new_keys                r�_handle_structurez'BaseXMLResponseParser._handle_structure�s������-�-���>�>���k�5�1��'�'��-�D��/�/��5���0�0���A��%�%�h�/�C��;�;�C�@�@�"�	A�K�"�;�/�L��l�8�8�8��-�-�1�1�-�@���,�,�\�;�G�H�"�,�,�x�0�K��&�&*�&7�&7� �+�'��{�#��+�+�/�/��?��� ,� :� :�6� B�
�"&�+�+�"3�"3�"5�-�J�C��"�0�0�4�4�%�+�+�C�0��3�c�9�3��G�(-�G�G�$�	-�
!�G�+�*1�-�*@�F�;�'�1	A�2�
rc�l�|j|�dk(r|D]}|j|�dk(s�|cS|S)N�
ErrorResponserk�r�)r�
original_root�childs   rr�z%BaseXMLResponseParser._get_error_root�s@���>�>�-�(�O�;�&�
!���>�>�%�(�G�3� �L�
!��rc���|jdk(rD|jjd�r)|jjjd�}|�|S|jjd�}|�|S|S)Nr�r�r�)r{rOrPr�)rr(r��list_member_serialized_name�serialized_names     rr�z&BaseXMLResponseParser._member_key_name�sw��
�?�?�f�$��)<�)<�)@�)@��)M�*/�,�,�*D�*D�*H�*H��+�'�+�6�2�2��-�-�1�1�&�9���&�"�"��rc��t|t�r|j|d�Si}|D]O}|j|�}||vr3t||t�r||j	|��@|||g||<�K|||<�Q|Sr�)rQr�r�r�r�)r�parent_noder�r�r�s     rr�z-BaseXMLResponseParser._build_name_to_xml_node�s����k�4�(��/�/��A��?�?����
	%�D��.�.��&�C��h��
�h�s�m�T�2��S�M�(�(��.�&.�c�]�D�$9�H�S�M� $���
�
	%��rc���	tjtj�|j��}|j	|�|j�}|S#t$r}td|�d|����d}~wwxYw)N)�target�encodingzUnable to parse response (z6), invalid XML received. Further retries may succeed:
)r�	XMLParser�TreeBuilderr��feed�closerr.)r�
xml_stringr��root�es     r�_parse_xml_string_to_domz.BaseXMLResponseParser._parse_xml_string_to_dom�st��	��_�_��(�(�*�T�5J�5J��F�
�K�K�
�#��<�<�>�D����
�	�%��j�"��
��	�s�AA�	A7�!A2�2A7c��|j�D]E\}}t|�r&|j|�}|j|�||<�7|j||<�G|Sr)r�r�r��_replace_nodesr%)rrUr�r>�sub_dicts     rr�z$BaseXMLResponseParser._replace_nodessZ�� �,�,�.�	)�J�C���E�{��7�7��>��"�1�1�(�;��s��#�j�j��s��	)��
rc��|dk(ryy)N�trueTFr�rr(r%s   r�_handle_booleanz%BaseXMLResponseParser._handle_booleans���6�>��rc��t|�Sr)�floatr�s   r�
_handle_floatz#BaseXMLResponseParser._handle_floats���T�{�rc�$�|j|�Sr�r3r�s   r�_handle_timestampz'BaseXMLResponseParser._handle_timestamps���%�%�d�+�+rc��t|�Sr��intr�s   r�_handle_integerz%BaseXMLResponseParser._handle_integers���4�y�rc��|Srrr�s   r�_handle_stringz$BaseXMLResponseParser._handle_strings���rc�$�|j|�Sr�r5r�s   r�_handle_blobz"BaseXMLResponseParser._handle_blob#s��� � ��&�&rr�)rrr rr�r�r�r�r�r�r�r�r�r,r�r�r�r�r�r��_handle_character�_handle_double�_handle_long�
__classcell__�rts@rr�r�{s����0��*4�1�"�H�� �.
�����������,��,����������'��'�'��"�N�"�Lrr�c�2�eZdZd�Zd�Zd�Zdd�Zd�Zd�Zy)	�QueryParserc���|d}|j|�}|j|�}|j|�d|vr |j|j	d��d|vrd|j	d�i|d<|S)NrA�Errors�	RequestIdrD)r�r�r�rr�)rrTr(�xml_contentsr�rUs      rrMzQueryParser._do_error_parse-s����'���,�,�\�:���-�-�d�3�����F�#��v���M�M�&�*�*�X�.�/��&� �*5�v�z�z�+�7N�)O�F�%�&��
rc�*�|j||d��S)NF��inject_metadata��_parse_body_as_xmlrus   rrLz#QueryParser._do_modeled_error_parse=s���&�&�x���&�N�Nrc�*�|j||d��S)NTrr
rus   rrNzQueryParser._do_parse@s���&�&�x���&�M�Mrc���|d}|j|�}i}|�A|}d|jvr|j|jd|�}|j||�}|r|j	||�|S)NrA�
resultWrapper)r�rO�_find_result_wrapped_shaper�_inject_response_metadata)rrTr(r	rr�rU�starts        rrzQueryParser._parse_body_as_xmlCs�����'���,�,�\�:�������E��%�"5�"5�5��7�7��'�'��8�$����&�&�u�e�4�F���*�*�4��8��
rc�.�|j|�}||Sr)r�)r�element_name�
xml_root_node�mappings    rrz&QueryParser._find_result_wrapped_shapeRs���.�.�}�=���|�$�$rc���|j|�}|jd�}|�>|j|�}|j�D]\}}|j||<�||d<yy�NrD)r�rPr�r%)rr}�inject_intor�
child_node�sub_mappingr�r>s        rrz%QueryParser._inject_response_metadataVsq���.�.�t�4���[�[�!3�4�
��!��6�6�z�B�K�)�/�/�1�
.�
��U�#(�:�:��C� �
.�.9�K�*�+�	"rN)T)	rrr rMrLrNrrrrrrrr,s"��� O�N�
�%�:rrc�*��eZdZd�Z�fd�Zd�Z�xZS)�EC2QueryParserc�p�|j|�}|jd�}|�d|ji|d<yy)N�	requestIdrrD)r�rPr%)rr}rrrs     rrz(EC2QueryParser._inject_response_metadataas?���.�.�t�4���[�[��-�
��!�/:�J�O�O�.L�K�*�+�"rc�\��t�|�||�}d|vrd|jd�i|d<|S)N�	RequestIDrrD)r�rMr�)rrTr(�originalrts    �rrMzEC2QueryParser._do_error_parsegs@����7�*�8�U�;���(�"��X�\�\�+�6�,�H�'�(��rc��|D]8}|j|�dk(s�|D]}|j|�dk(s�|ccS�:|S)Nrrkr�)rr�r��errors_childs    rr�zEC2QueryParser._get_error_root{sP��"�	,�E��~�~�e�$��0�$)�,�L��~�~�l�3�w�>�+�+�,�	,�
�r)rrr rrMr�r�rs@rrr`s���M��(rrc�<�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�BaseJSONParserc�\�i}|jr|}|S|j}|�yi}|j||�r"|j|�}|j	|�S|D]O}||}|j
j
d|�}|j
|�}	|	��8|j|||	�||<�Q|S)Nr�)�is_document_typer�r�r�r�rOrPr)
rr(r>�final_parsed�
member_shapesr�r�r��	json_name�	raw_values
          rr�z BaseJSONParser._handle_structure�s������!�!� �L�(��%"�M�M�M��}���L��4�4�U�E�B��)�)�%�0���?�?��D�D�,�
��,�[�9��(�6�6�:�:�6�;�O�	�!�I�I�i�0�	��(�04�0A�0A�%�k�2�I�1�L��-�
��rc��i}|j}|j}|j�D].\}}|j||�}|j||�}|||<�0|Sr)r�r>r�r)	rr(r>rUr�r�r��
actual_key�actual_values	         rr�zBaseJSONParser._handle_map�sg�����I�I�	��k�k���+�+�-�	.�J�C���*�*�9�c�:�J��,�,�[�%�@�L�!-�F�:��	.��
rc�$�|j|�Srr�r�s   rr�zBaseJSONParser._handle_blob�s��� � ��'�'rc�$�|j|�Srr�r�s   rr�z BaseJSONParser._handle_timestamp�s���%�%�e�,�,rc��|j|d�}ddd�id�}|d}|jd|jdd��|dd<|jd	�}|jd
|xrt|��}|�8d|vr|jdd�d}d
|vr|j	|||�}||dd<|j||d�|S)NrAr&�rirhrjr@�messagerirkrBr��#r��x-amzn-query-errorrh)�_parse_body_as_jsonrPrl�rsplit� _do_query_compatible_error_parser)rrTr(rA�errorr@�
response_code�codes        rrMzBaseJSONParser._do_error_parse�s����'�'���(8�9��&(�"�5�2�N���9�%��%)�H�H��t�x�x�	�2�.�%
��g��y�!�
!���]�3�
��x�x��-�"F�C�
�4F�G�����d�{��{�{�3��*�1�-��#�w�.��<�<��'�5���&*�E�'�N�6�"��&�&�u�h�y�.A�B��rc��|d}|jd�}t|�dk(r|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.
        r5�;�rrk�QueryErrorCoder��Type)r�r�)rr;r@r9�query_error�query_error_componentss      rr8z/BaseJSONParser._do_query_compatible_error_parse�sh���2�3��!,�!2�!2�3�!7���%�&�!�+�0F�q�0I�/3�E�'�N�+�,�%;�A�%>�E�'�N�6�"�)�!�,�,��rc�>�d|vr|d|jdi�d<yy)N�x-amzn-requestidrDr)�
setdefault)rrUr@s   rrz(BaseJSONParser._inject_response_metadata�s0����(�EL�"�F�F���0�"�5�k�B�)rc��|siS|j|j�}	tj|�}|S#t$rd|icYSwxYw)Nr3)�decoder��json�loads�
ValueError)r�
body_contentsrA�original_parseds    rr6z"BaseJSONParser._parse_body_as_json�sU����I��#�#�D�$9�$9�:��	%�"�j�j��.�O�"�"���	%��t�$�$�	%�s�8�
A�AN)rrr r�r�r�r�rMr8rr6rrrr%r%�s+���2�(�-� �D
��
%rr%c�*�eZdZd�Zd�Zd�Zd�Zd�Zy)�BaseEventStreamParserc�H�i}|jjd�rH|djd�}|jj|�}|r|j||�||<|S|j	|||j|�|j|||j|�|S)NrCr@z:event-type)rOrPr�rN�_parse_non_payload_attrs�_parse_payload)rrTr(r(�
event_type�event_shapes      rrNzBaseEventStreamParser._do_parse�s��������"�"�=�1�!�)�,�0�0��?�J��-�-�+�+�J�7�K��+/�>�>��k�,��Z�(���	
�)�)��%�����
�
����%�����M��rc	�`�|djd�}|jj|�}|�O|j|d�}|j||�}d||jd|jdd��d�i}|Sd|djd	d�|djd
d�d�i}|S)Nr@z:exception-typerArkrir3r&rgz:error-codez:error-message)rPr��_initial_body_parser)rrTr(�exception_type�exception_shaperLrAr9s        rrMz%BaseEventStreamParser._do_error_parses���!�)�,�0�0�1B�C���-�-�+�+�N�;���&�"�6�6�x��7G�H�O��$�$�_�o�F�D��*�#�x�x�	�4�8�8�I�r�3J�K���E����$�Y�/�3�3�M�2�F�'�	�2�6�6�7G��L���E��rc���|jjd�r�|D]�}||}|jjd�s�$|d}|jdk(r|}nN|jdk(r|j|j�}n#|j|�}	|j
||	�}|||<y|j|d�}
|j
||
�}|j|�yy)N�event�eventpayloadrA�blob�string)rOrPr{rGr�rUrr)rrTr(r)r(r�r�rA�parsed_body�	raw_parserL�body_parseds            rrQz$BaseEventStreamParser._parse_payloads������"�"�7�+�%�
��,�T�2���-�-�1�1�.�A�#�F�+�D�#�-�-��7�&*��%�/�/�8�;�&*�k�k�$�2G�2G�&H��$(�$<�$<�T�$B�	�&*�&7�&7�(�)�'��*5�L��&��
� #�6�6�x��7G�H�O��+�+�E�?�C�K�����,�',rc���|d}|D]U}||}|jjd�s�$||vs�)||}|jdk(r|j|dz�}|||<�Wy)Nr@r��	timestampg@�@)rOrPr{r3)	rrTr(r)r(r@r�r�r>s	         rrPz.BaseEventStreamParser._parse_non_payload_attrs.sy���9�%��!�		/�D�(��.�L��)�)�-�-�m�<��7�?�#�D�M�E�#�-�-��<�!%� 6� 6�u�v�~� F��).�L��&�		/rc��td���NrU�rs�rrKs  rrUz)BaseEventStreamParser._initial_body_parse=���
"�"7�8�8rN)rrr rNrMrQrPrUrrrrNrN�s��� �*-�,
/�9rrNc��eZdZd�Zy)�EventStreamJSONParserc�$�|j|�Sr�r6res  rrUz)EventStreamJSONParser._initial_body_parseF����'�'�
�6�6rN�rrr rUrrrrhrhEs��7rrhc��eZdZd�Zy)�EventStreamXMLParserc�R�|stjd�S|j|�Sr��r�Elementr��rr�s  rrUz(EventStreamXMLParser._initial_body_parseK�%����=�=��$�$��,�,�Z�8�8rNrlrrrrnrnJs��9rrnc�*�eZdZeZ	d�Zd�Zd�Zd�Zy)�
JSONParserc��i}|�7|j}|r|j|||�}n|j|d|�}|j||d�|S)NrAr@)�event_stream_name�_handle_event_stream�_handle_json_bodyr)rrTr(rU�
event_names     rrNzJSONParser._do_parseVs`�������0�0�J���2�2�8�U�J�O���/�/���0@�%�H���&�&�v�x�	�/B�C��
rc�,�|j|d|�S)NrA)ryrus   rrLz"JSONParser._do_modeled_error_parseas���%�%�h�v�&6��>�>rc���|j|}|j||�}	|j�}|j|j|�}|||<|S#t$rd}t	|��wxYw)Nz,First event was not of type initial-response)r�r��get_initial_responserr.ry�payload)	rrTr(rz�event_stream_shape�event_streamrYr�rUs	         rrxzJSONParser._handle_event_streamds��"�]�]�:�6���0�0��;M�N��	1� �5�5�7�E��'�'��
�
�u�=��)��z���
��&�	1�F�I�%�i�0�0�	1�s�A�A-c�H�|j|�}|j||�Sr)r6r)r�raw_bodyr(�parsed_jsons    rryzJSONParser._handle_json_bodyps'���.�.�x�8��� � ���4�4rN)	rrr rhr7rNrLrxryrrrruruQs��3��2�	�?�
�5rruc�T��eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Z�fd
�Z�xZ
S)�BaseRestParserc�X�i}|j|�|d<|j|||�|Sr)�_populate_response_metadata�_add_modeled_parse�rrTr(r(s    rrNzBaseRestParser._do_parseys:����+/�+K�+K��,
��'�(�	
����%��>��rc�t�|�|S|j}|j||||�|j||||�yr)r�rPrQ)rrTr(r(r)s     rr�z!BaseRestParser._add_modeled_parse�sC���=����
�
�
��%�%��e�]�L�	
�	
���H�e�]�L�Irc�0�i}|j|||�|Sr)r�r�s    rrLz&BaseRestParser._do_modeled_error_parse�s��������%��>��rc�r�i}|d}d|vr
|d|d<|Sd|vr|d|d<|jdd�|d<|S)Nr@rDr�x-amz-request-id�
x-amz-id-2r&�HostIdr])rrTrbr@s    rr�z*BaseRestParser._populate_response_metadata�sf�����9�%����(�$+�,>�$?�H�[�!���
 �7�
*�$+�,>�$?�H�[�!�")���\�2�!>�H�X���rc��d|jvr�|jd}||}|jjd�r|j||�}|||<y|jdvr6|d}t	|t
�r|j
|j�}|||<y|j|d�}|j||�||<y|j|d�}|j||�}	|j|	�y)Nr~rC)r\r[rA)rOrPr�r{rQ�bytesrGr�rUrr)
rrTr(r)r(�payload_member_name�
body_shaperArLr_s
          rrQzBaseRestParser._parse_payload�s����+�+�+�#(�"5�"5�i�"@��&�':�;�J��'�'�+�+�M�:��0�0��:�F��48��0�1��%�%�);�;���'���d�E�*��;�;�t�'<�'<�=�D�48��0�1�"&�":�":�8�F�;K�"L��48�4E�4E���5��0�1�#�6�6�x��7G�H�O��+�+�E�?�C�K�����,rc�R�|d}|D]�}||}|jjd�}|��&|dk(r|j||d�||<�D|dk(r|j||�||<�_|dk(s�e|jjd|�}	|	|vs��|j|||	�||<��y)Nr@r��
statusCoderB�headerr�)rOrPr�_parse_header_map)
rrTr(r)r(r@r�r�r��header_names
          rrPz'BaseRestParser._parse_non_payload_attrs�s����9�%��!�	�D�(��.�L�#�1�1�5�5�j�A�H�����\�)�%)�%6�%6� �(�=�"9�&��T�"��Y�&�%)�%;�%;� �'�&��T�"��X�%�*�8�8�<�<�V�T�J���'�)�)-�):�):�$�g�k�&:�*�L��&�!	rc���i}|jjdd�j�}|D]8}|j�j|�s�#|t	|�d}||||<�:|S)Nr�r&)rOrP�lowerrer�)rr(r@rU�prefixr�r�s       rr�z BaseRestParser._parse_header_map�sw�����$�$�(�(���4�:�:�<��"�	4�K�� � �"�-�-�f�5�#�3�v�;�=�1��&�{�3��t��	4��
rc��td��rcrdres  rrUz"BaseRestParser._initial_body_parse�rfrc��|}t|�rCtj|�j|j�}tj|�}|Sr)rr;r<rGr�rHrI)rr(r>rU�decodeds     rr�zBaseRestParser._handle_string�sC������&��&�&�u�-�4�4�T�5J�5J�K�G��Z�Z��(�F��
rc����|jjd�}|dk(r<t|t�s,|j	d�D�cgc]}|j���}}t�|�||�Scc}w)Nr�r��,)rOrPrQr�r�rdr�r�)rr(r}r�r�rts     �rr�zBaseRestParser._handle_list�sb����&�&�*�*�:�6���x��
�4��(>�'+�z�z�#��7�!�A�G�G�I�7�D�7��w�#�E�4�0�0��8s�A.)rrr rNr�rLr�rQrPr�rUr�r�r�rs@rr�r�xs;����J��
�-�2�0�9��1�1rr�c�8��eZdZeZd�Z�fd�Zd�Zd�ZeZ	�xZ
S)�RestJSONParserc�$�|j|�Srrjres  rrUz"RestJSONParser._initial_body_parse�rkrc�L��t�|�||�}|j||�|Sr)r�rM�_inject_error_code)rrTr(r9rts    �rrMzRestJSONParser._do_error_parse�s)�����'��%�8������x�0��rc���|j|d�}d|dvr%|dd}|jd�d}||dd<yd|vsd|vr)|jd|jdd	��|dd<yy)
NrAzx-amzn-errortyper@r�rrkrhr;r&)rUr�rP)rr9rTrAr;s     rr�z!RestJSONParser._inject_error_code�s����'�'���(8�9����)�!4�4��I�&�'9�:�D��:�:�c�?�1�%�D�%)�E�'�N�6�"�
�t�^�v��~�%)�X�X�f�d�h�h�v�r�6J�%K�E�'�N�6�"� .rc��t|�Srr�r�s   rr�zRestJSONParser._handle_integers���5�z�r)rrr rhr7rUrMr�r�r�r�rs@rr�r��s%���3��7��
L��#�Lrr�c�D��eZdZeZd�Zd�Zd�Zd�Ze	�fd��Z
�xZS)�
RestXMLParserc�R�|stjd�S|j|�Sr�rprrs  rrUz!RestXMLParser._initial_body_parsersrc��|dr	|j|�S|j	|�S#t$rtjdd��Y�3wxYw)NrAz2Exception caught when parsing error response body:T)�exc_info)�_parse_error_from_bodyr.rGrH�_parse_error_from_http_statusrus   rrMzRestXMLParser._do_error_parses]���F��
��2�2�8�<�<��1�1�(�;�;��'�
��	�	�H�!���
�s�)� A�Ac���t|d�tjjj	|dd�d�|dj	dd�|dj	dd�d�d�S)	NrBr&rgr@r�r�)rr�rj)rlrmrnrorPrps  rr�z+RestXMLParser._parse_error_from_http_status1st���H�]�3�4��;�;�0�0�4�4��]�+�R���&�i�0�4�4�5G��L�"�9�-�1�1�,��C�!�
�	
rc�b�|d}|j|�}|j|�}|j|�|jdk(r:|j	|�}|jdd�|jdd�||d�Sd|vrd|jd�i|d<dddd�i}t
||�|S)	NrArkrr&r�rjrDr2)r�r�r�r�r�r�r	)rrTrr�rUrb�defaults       rr�z$RestXMLParser._parse_error_from_body?s�����'���,�,�\�:���-�-�d�3�����F�#��8�8�w���7�7��A�H�

�J�J�{�B�'��J�J�x��$�#��B�B�
�F�
"�*5�v�z�z�+�7N�)O�F�%�&���B�7�8���G�V�$��rc�(��t�|�||�}|Sr)r�r�)rr(r%rts   �rr�zRestXMLParser._handle_stringVs����w�%�e�T�2���r)rrr rnr7rUrMr�r�r,r�r�rs@rr�r�s1���2��9�
<�6
��.���rr�)�ec2�queryrHz	rest-jsonzrest-xml)(r�r;�http.clientrmrH�loggingr��botocore.compatrr�botocore.eventstreamrr�botocore.utilsrrr	r
�	getLoggerrrGr2rrr,�	Exceptionr.r0r�rrr%rNrhrnrur�r�r�rrrr�<module>r�s0��g�P����	�0�D����g����!��*��,�,�*;��*	�)�	�}5�}5�@n#�N�n#�b1:�'�1:�h!�[�!�Hk%�^�k%�\P9�N�P9�f7�1�>�7�
9�0�2G�9�$5��$5�Nu1�^�u1�p#�^�^�#�<K�N�$9�K�^�
�����r