Edit File: sessions.cpython-311.pyc
� ������Fh�u����������������������������d�Z�ddlZddlZddlZddlmZ�ddlmZ�ddlm Z �ddl mZmZm Z mZmZ�ddlmZmZmZmZ�dd lmZmZmZ�dd lmZmZ�ddlmZ�ddlmZm Z m!Z!�dd l"m#Z#m$Z$m%Z%m&Z&�ddl'm(Z(�ddl)m*Z*�ddlm+Z+m,Z,m-Z-m.Z.m/Z/m0Z0�ddl1m2Z2�ddlm3Z3�ej4��������dk����r �ej5��������Z6n#�e7$�r �ej8��������Z6Y�nw�xY�wej��������Z6efd�Z9efd�Z:�G�d��de;������������Z<�G�d��de<������������Z=d��Z>dS�)z� requests.sessions ~~~~~~~~~~~~~~~~~ This module provides a Session object to manage and persist settings across requests (cookies, auth, proxies). �����N)� timedelta)�OrderedDict����)�_basic_auth_str)� cookielib�is_py3�urljoin�urlparse�Mapping)�cookiejar_from_dict�extract_cookies_to_jar�RequestsCookieJar� merge_cookies)�Request�PreparedRequest�DEFAULT_REDIRECT_LIMIT)� default_hooks� dispatch_hook)�to_native_string)�to_key_val_list�default_headers� DEFAULT_PORTS)�TooManyRedirects� InvalidSchema�ChunkedEncodingError�ContentDecodingError)�CaseInsensitiveDict)�HTTPAdapter)�requote_uri�get_environ_proxies�get_netrc_auth�should_bypass_proxies�get_auth_from_url�rewind_body)�codes)�REDIRECT_STATI�win32c������������������.����|�|�S�|��|S�t����������|t����������������������rt����������|�t����������������������s|�S��|t����������|������������������������}|���������������������t����������|��������������������������d��|�����������������������������������D���������������}|D�]}||=��|S�)z�Determines appropriate setting for a given request, taking into account the explicit setting on that request, and the setting in the session. If a setting is a dictionary, they will be merged together using `dict_class` Nc�����������������������g�|�] \��}}|�|�� S��N��)�.0�k�vs��� �H/opt/imunify360/venv/lib64/python3.11/site-packages/requests/sessions.py� <listcomp>z!merge_setting.<locals>.<listcomp>J���s������E�E�E�v��1�1�9��9�9�9�����)� isinstancer���r����update�items)�request_setting�session_setting� dict_class�merged_setting� none_keys�keys��� r/���� merge_settingr;���2���s����������������� ���0�0�����0�0������Z��� @� @�A�A�N����/�/�:�:�;�;�;��F�E��!5�!5�!7�!7�E�E�E�I��� �� ���3����r1���c�����������������������|�|����������������������d������������g�k����r|�S�|��|�����������������������d������������g�k����r|S�t����������|�||������������S�)z�Properly merges both requests and session hooks. This is necessary because when request_hooks == {'response': []}, the merge breaks Session hooks entirely. N�response)�getr;���)� request_hooks� session_hooksr7���s��� r/����merge_hooksrA���Q���s^��������� � 1� 1�*� =� =�� C� C����� � 1� 1�*� =� =�� C� C����� �z�B�B�Br1���c��������������������8�����e�Zd�Zd��Zd��Z � �d d�Zd��Zd��Zd ��ZdS�)�SessionRedirectMixinc�����������������������|j���������r9|j��������d���������}t����������r|���������������������d������������}t ����������|d������������S�dS�)z7Receives a Response. Returns a redirect URI or ``None``�location�latin1�utf8N)�is_redirect�headersr����encoder���)�self�resprE���s��� r/����get_redirect_targetz(SessionRedirectMixin.get_redirect_targetb���sK���������� 6��|�J�/�H���� 5�#�?�?�8�4�4��#�H�f�5�5�5��tr1���c������������������b����t����������|������������}t����������|������������}|j��������|j��������k����rdS�|j��������dk����r|j��������dv�r|j��������dk����r|j��������dv�rdS�|j��������|j��������k����}|j��������|j��������k����}t ����������j��������|j��������d������������df}|s|j��������|v�r|j��������|v�rdS�|p|S�)zFDecide whether Authorization header should be removed when redirectingT�http)�P���N�https)i���NFN)r ����hostname�scheme�portr���r>���)rK����old_url�new_url� old_parsed� new_parsed�changed_port�changed_scheme�default_ports��� r/����should_strip_authz&SessionRedirectMixin.should_strip_authw���s��������g�&�&� ��g�&�&� ���*�"5�5�5��4� � ���'�'�J�O�z�,I�,I��%��0�0�Z�_��5S�5S��5��"��*�/�9��#�*�j�.?�?��%�)�*�*;�T�B�B�D�I���� �:�?�l�#B�#B��O�|�3�3��5���-�~�-r1���FNTc ����������� ���+�������K����g�} |�����������������������|������������}t����������|j��������������������j��������}|�r6|�����������������������������������} | ���������������������|�������������| dd����������|_�������� �|j���������n8#�t����������t����������t����������f$�r�|j�����������������������������d��������������Y�nw�xY�wt����������|j��������������������|�j��������k����r)t����������d���������������������|�j��������������������|��������������|������������������������������������|���������������������d������������r=t����������|j��������������������}d���������������������t)����������|j��������������������|g������������}t����������|������������}|j��������d k����r|r|���������������������|� ������������}n|j��������r|j��������}|�����������������������������������}|j��������s#t3����������|j��������t5����������|������������������������}nt5����������|������������}t)����������|������������| _��������|����������������������| |�������������|j��������t:����������j��������t:����������j��������fvr)d}|D�]}| j ���������!��������������������|d��������������d| _"��������| j ��������}|�!��������������������dd�������������tG����������| j$��������||j���������������������tK����������| j$��������|�j&���������������������| �'��������������������| j$���������������������|��(��������������������| |������������}|��)��������������������| |�������������| j*��������duod |v�pd|v�}|rtW����������| �������������| }|r|V���nI�|�j,��������|f|||||dd�| ��}tG����������|�j&��������| |j���������������������|�����������������������|������������}|V���|��4dS�dS�)zBReceives a Response. Returns a generator of Responses or Requests.r���NF)�decode_contentzExceeded {} redirects.)r=���z//�:��)�fragment)�Content-LengthzContent-Type�Transfer-Encoding�Cookierb���rc���)�stream�timeout�verify�cert�proxies�allow_redirects)-rM���r ����urlra����copy�append�history�contentr���r����RuntimeError�raw�read�len� max_redirectsr����format�close� startswith�joinr���rS����_replace�geturl�netlocr ���r����rebuild_method�status_coder%����temporary_redirect�permanent_redirectrI����pop�bodyr ����_cookiesr����cookies�prepare_cookies�rebuild_proxies�rebuild_auth�_body_positionr$����send)rK���rL����reqre���rf���rg���rh���ri����yield_requests�adapter_kwargs�histrk����previous_fragment�prepared_request�parsed_rurl�parsed�purged_headers�headerrI���� rewindables��� r/����resolve_redirectsz&SessionRedirectMixin.resolve_redirects����s��������������&�&�t�,�,��$�S�W�-�-�6����d �"�x�x�z�z��� �K�K���������8�D�L� 4������(�*>��M�� 4�� 4�� 4��� � �U� �3�3�3�3�3� 4������4�<� � �D�$6�6�6�&�'?�'F�'F�t�GY�'Z�'Z�ei�j�j�j�j�� �J�J�L�L�L���~�~�d�#�#�� L�&�t�x�0�0���h�h� 0��1C� D� D�c�J�K�K����c�]�]�F���"�$�$�):�$����2C��D�D������ 4�$*�O�!��-�-�/�/�C� ��=�� '��d�h��C�(8�(8�9�9���!�#�&�&��#3�C�#8�#8�� ���� 0�$�7�7�7�����(@�%�BZ�'[�[�[�!X��,��?��?�F�$�,�0�0���>�>�>�>�(,� �%�&�.�G��K�K��$�'�'�'� � #�#3�#<�c�4�8�L�L�L��*�3�T�\�B�B�B��,�,�-=�-F�G�G�G���*�*�+;�W�E�E�G����.��5�5�5��!�/�t�;��P�!�W�,�N�0C�w�0N�� ���� .��,�-�-�-��#�C��� �� � � � ��!�t�y�� �!�#�!��#�$)� �� ��%� �� ���'�t�|�5E�t�x�P�P�P���.�.�t�4�4��� � � �I���d ��d ��d ��d ��d s����/A7��72B,�+B,c������������������������|j���������}|j��������}d|v�r#|����������������������|j��������j��������|������������r|d=�|�j��������rt����������|������������nd}|�|���������������������|�������������dS�dS�)z�When being redirected we may want to strip authentication from the request to avoid leaking credentials. This method intelligently removes and reapplies authentication where possible to avoid credential loss. � AuthorizationN)rI���rk���r\����request� trust_envr!����prepare_auth)rK���r����r=���rI���rk����new_auths��� r/���r����z!SessionRedirectMixin.rebuild_auth����s������� �#�*���"���g�%�%�$�*@�*@��AQ�AU�WZ�*[�*[�%����(��+/�.�B�>�#�&�&�&�d�����)�)�(�3�3�3�3�3�� �r1���c����������������������|�|ni�}|j���������}|j��������}t����������|������������j��������}|�����������������������������������}|���������������������d������������}t ����������||�������������}|�j��������rT|sRt����������||�������������} | ���������������������|| ���������������������d������������������������} | r|� ��������������������|| �������������d|v�r|d=� �t����������||���������������������\��}}n#�t����������$�r�d\��}}Y�nw�xY�w|r|rt����������||������������|d<���|S�)a���This method re-evaluates the proxy configuration by considering the environment variables. If we are redirected to a URL covered by NO_PROXY, we strip the proxy configuration. Otherwise, we set missing proxy keys for this URL (in case they were stripped by a previous redirect). This method also replaces the Proxy-Authorization header where necessary. :rtype: dict N�no_proxy�r�����allzProxy-Authorization�NN) rI���rk���r ���rS���rl���r>���r"���r����r ���� setdefaultr#����KeyErrorr���) rK���r����ri���rI���rk���rS����new_proxiesr�����bypass_proxy�environ_proxies�proxy�username�passwords ��� r/���r����z$SessionRedirectMixin.rebuild_proxies��sM������%�0�'�'�b��"�*���"���#���%���l�l�n�n���;�;�z�*�*��,�S�8�D�D�D���>�� 6�,�� 6�1�#��I�I�I�O�#�'�'���0C�0C�E�0J�0J�K�K�E��� 6��&�&�v�u�5�5�5� �G�+�+��-�.� ,�!2�;�v�3F�!G�!G��H�h�h���� ,�� ,�� ,�!+��H�h�h�h� ,������� Q��� Q�-<�X�x�-P�-P�G�)�*��s����C��C1�0C1c������������������������|j���������}|j��������t����������j��������k����r|dk����rd}|j��������t����������j��������k����r|dk����rd}|j��������t����������j��������k����r|dk����rd}||_���������dS�)z�When being redirected we may want to change the method of the request based on certain specs or browser behavior. �HEAD�GET�POSTN)�methodr}���r%���� see_other�found�moved)rK���r����r=���r����s��� r/���r|���z#SessionRedirectMixin.rebuild_method:��s~�������"�(�����5�?�2�2�v��7G�7G��F����5�;�.�.�6�V�3C�3C��F����5�;�.�.�6�V�3C�3C��F�"(����r1���)FNTNNF) �__name__� __module__�__qualname__rM���r\���r����r����r����r|���r+���r1���r/���rC���rC���`���s��������������������*.��.��.�2�BF�OT�l��l��l��l�\4��4��4�&'��'��'�R)��)��)��)��)r1���rC���c�������������������������e�Zd�ZdZg�d�Zd��Zd��Zd��Zd��Z � � �dd �Z d ��Z d��Zd��Zdd �Z dd�Zdd�Zd��Zd��Zd��Zd��Zd��Zd��Zd��Zd��ZdS�)�Sessiona���A Requests session. Provides cookie persistence, connection-pooling, and configuration. Basic Usage:: >>> import requests >>> s = requests.Session() >>> s.get('https://httpbin.org/get') <Response [200]> Or as a context manager:: >>> with requests.Session() as s: ... s.get('https://httpbin.org/get') <Response [200]> )rI���r�����authri����hooks�paramsrg���rh����adaptersre���r����rt���c����������������������t������������������������|�_��������d�|�_��������i�|�_��������t ������������������������|�_��������i�|�_��������d|�_��������d|�_��������d�|�_ ��������t����������|�_��������d|�_��������t����������i�������������|�_��������t������������������������|�_��������|����������������������dt%�������������������������������������|����������������������dt%�������������������������������������d�S�)NFTzhttps://zhttp://)r���rI���r����ri���r���r����r����re���rg���rh���r���rt���r����r���r����r���r�����mountr����rK���s��� r/����__init__zSession.__init__j��s������� �'�(�(������ � �����#�_�_�� � ��������������� ��4��������+�2�.�.����$� � �� �� � �:�{�}�}�-�-�-�� � �9�k�m�m�,�,�,�,�,r1���c�����������������������|�S�r*���r+���r����s��� r/���� __enter__zSession.__enter__���s�������r1���c������������������.�����|��������������������������������������d�S�r*���)rv���)rK����argss��� r/����__exit__zSession.__exit__���s������� � �����r1���c����������������������|j���������pi�}t����������|t����������j��������������������st ����������|������������}t����������t����������t ������������������������|�j���������������������|������������}|j��������}|�j��������r|s|�j��������st����������|j ��������������������}t������������������������}|���������������������|j �������������������������������������������|j ��������|j��������|j��������|j��������t%����������|j��������|�j��������t(�����������������������t%����������|j��������|�j��������������������t%����������||�j��������������������|t-����������|j��������|�j���������������������� ��� ���������|S�)a���Constructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it. The :class:`PreparedRequest` has settings merged from the :class:`Request <Request>` instance and those of the :class:`Session`. :param request: :class:`Request` instance to prepare with this session's settings. :rtype: requests.PreparedRequest )r7���) r����rk����files�data�jsonrI���r����r����r����r����)r����r2���r���� CookieJarr���r���r���r����r����r!���rk���r����preparer�����upperr����r����r����r;���rI���r���r����rA���r����)rK���r����r�����merged_cookiesr�����ps��� r/����prepare_requestzSession.prepare_request���s.�������/�'�R����'�9�#6�7�7�� 3�)�'�2�2�G��'��+�-�-�t�|�<�<�g�G��G����|���>�� /�$�� /�t�y�� /�!�'�+�.�.�D����� � � ��>�'�'�)�)����-�����!�'�/�4�<�L_�`�`�`� �����=�=��t�T�Y�/�/�"��g�m�T�Z�8�8�� �� �� �� ���r1���NTc������������������"����t����������|�����������������������������������||||pi�||pi�|||�� ��� ��������}|����������������������|������������}|pi�}|����������������������|j��������|| ||������������}| | d�}|���������������������|��������������|�j��������|fi�|��}|S�)ax ��Constructs a :class:`Request <Request>`, prepares it and sends it. Returns :class:`Response <Response>` object. :param method: method for the new :class:`Request` object. :param url: URL for the new :class:`Request` object. :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`. :param data: (optional) Dictionary, list of tuples, bytes, or file-like object to send in the body of the :class:`Request`. :param json: (optional) json to send in the body of the :class:`Request`. :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. :param files: (optional) Dictionary of ``'filename': file-like-objects`` for multipart encoding upload. :param auth: (optional) Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth. :param timeout: (optional) How long to wait for the server to send data before giving up, as a float, or a :ref:`(connect timeout, read timeout) <timeouts>` tuple. :type timeout: float or tuple :param allow_redirects: (optional) Set to True by default. :type allow_redirects: bool :param proxies: (optional) Dictionary mapping protocol or protocol and hostname to the URL of the proxy. :param stream: (optional) whether to immediately download the response content. Defaults to ``False``. :param verify: (optional) Either a boolean, in which case it controls whether we verify the server's TLS certificate, or a string, in which case it must be a path to a CA bundle to use. Defaults to ``True``. When set to ``False``, requests will accept any TLS certificate presented by the server, and will ignore hostname mismatches and/or expired certificates, which will make your application vulnerable to man-in-the-middle (MitM) attacks. Setting verify to ``False`` may be useful during local development or testing. :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. :rtype: requests.Response ) r����rk���rI���r����r����r����r����r����r����r����)rf���rj���)r���r����r�����merge_environment_settingsrk���r3���r����)rK���r����rk���r����r����rI���r����r����r����rf���rj���ri���r����re���rg���rh���r����r�����prep�settings�send_kwargsrL���s��� r/���r����zSession.request���s�������\���<�<�>�>���������<�R���� �� �� ����#�#�C�(�(���-�R���2�2��H�g�v�v�t� �� ����.� �� ��� ���8�$�$�$��t�y��-�-��-�-���r1���c������������������L�����|����������������������dd��������������|�j��������d|fi�|��S�)z�Sends a GET request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response rj���Tr�����r����r�����rK���rk����kwargss��� r/���r>���zSession.get"��s7������� ���+�T�2�2�2��t�|�E�3�1�1�&�1�1�1r1���c������������������L�����|����������������������dd��������������|�j��������d|fi�|��S�)z�Sends a OPTIONS request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response rj���T�OPTIONSr����r����s��� r/����optionszSession.options-��s7������� ���+�T�2�2�2��t�|�I�s�5�5�f�5�5�5r1���c������������������L�����|����������������������dd��������������|�j��������d|fi�|��S�)z�Sends a HEAD request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response rj���Fr����r����r����s��� r/����headzSession.head8��s7������� ���+�U�3�3�3��t�|�F�C�2�2�6�2�2�2r1���c������������������&������|�j���������d|f||d�|��S�)a���Sends a POST request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param data: (optional) Dictionary, list of tuples, bytes, or file-like object to send in the body of the :class:`Request`. :param json: (optional) json to send in the body of the :class:`Request`. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response r����)r����r�����r����)rK���rk���r����r����r����s��� r/����postzSession.postC��s'��������t�|�F�C�H�d��H�H��H�H�Hr1���c������������������$������|�j���������d|fd|i|��S�)au��Sends a PUT request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param data: (optional) Dictionary, list of tuples, bytes, or file-like object to send in the body of the :class:`Request`. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response �PUTr����r�����rK���rk���r����r����s��� r/����putzSession.putP��s%��������t�|�E�3�<�<�T�<�V�<�<�<r1���c������������������$������|�j���������d|fd|i|��S�)aw��Sends a PATCH request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param data: (optional) Dictionary, list of tuples, bytes, or file-like object to send in the body of the :class:`Request`. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response �PATCHr����r����r����s��� r/����patchz Session.patch\��s%��������t�|�G�S�>�>�t�>�v�>�>�>r1���c������������������ ������|�j���������d|fi�|��S�)z�Sends a DELETE request. Returns :class:`Response` object. :param url: URL for the new :class:`Request` object. :param \*\*kwargs: Optional arguments that ``request`` takes. :rtype: requests.Response �DELETEr����r����s��� r/����deletezSession.deleteh��s ��������t�|�H�c�4�4�V�4�4�4r1���c������������������H����|����������������������d|�j���������������������|����������������������d|�j���������������������|����������������������d|�j���������������������|����������������������d|����������������������||�j���������������������������������t ����������|t����������������������rt����������d�������������|� ��������������������dd������������}|� ��������������������d������������}|j��������}|����������������������|j ���������������������}t������������������������}�|j��������|fi�|��}t������������������������|z ��} t!����������| � ������������|_��������t%����������d ||fi�|��}|j��������r*|j��������D�]"} t)����������|�j��������| j��������| j����������������������#t)����������|�j��������||j���������������������|r�|�j��������||fi�|��}d��|D���������������}ng�}|r1|���������������������d|�������������|� ����������������������������������}||_��������|s5 �t5�����������|�j��������||fd di|��������������|_��������n#�t8����������$�r�Y�nw�xY�w|s|j���������|S�)zISend a given PreparedRequest. :rtype: requests.Response re���rg���rh���ri���z#You can only send PreparedRequests.rj���T)rk���)�secondsr=���c�����������������������g�|�]}|��S�r+���r+���)r,���rL���s��� r/���r0���z Session.send.<locals>.<listcomp>���s������,�,�,��t�,�,�,r1���r���r����)r����re���rg���rh���r����ri���r2���r���� ValueErrorr����r>���r�����get_adapterrk����preferred_clockr����r����elapsedr���rn���r ���r����r����rq���r�����insert�next�_next� StopIterationro���) rK���r����r����rj���re���r�����adapter�start�rr����rL����genrn���s ��� r/���r����zSession.sendr��s������� ���(�D�K�0�0�0����(�D�K�0�0�0����&�$�)�,�,�,����)�T�%9�%9�'�4�<�%P�%P�Q�Q�Q���g�w�'�'�� D��B�C�C�C��!�*�*�%6��=�=�����H�%�%��� ����"�"�w�{�"�3�3��� �!�!��� �G�L��+�+�F�+�+���"�#�#�e�+���g�.�.�.�� �� �*�e�Q�9�9�&�9�9��� �9�� M��� �� M�� M��&�t�|�T�\�4�8�L�L�L�L��t�|�W�a�e�<�<�<���� �(�$�(��G�>�>�v�>�>�C�,�,��,�,�,�G�G��G���� ��N�N�1�a� � � ���� � �A��A�I���� � ��5�t�5�a��`�`�QU�`�Y_�`�`�a�a����� �� �� �� ��� ������� � �I�I��s����%#H �� H�Hc����������������������|�j���������r�|�|���������������������d������������nd}t����������||�������������}|�����������������������������������D�]\��}} |���������������������|| ��������������|du�s|�>t ����������j�����������������������������d������������pt ����������j�����������������������������d������������}t����������||�j��������������������}t����������||�j ��������������������}t����������||�j ��������������������}t����������||�j��������������������}||||d�S�)z^ Check the environment and merge it with some settings. :rtype: dict Nr����r����T�REQUESTS_CA_BUNDLE�CURL_CA_BUNDLE)rg���ri���re���rh���)r����r>���r ���r4���r�����os�environr;���ri���re���rg���rh���) rK���rk���ri���re���rg���rh���r�����env_proxiesr-���r.���s ��� r/���r����z"Session.merge_environment_settings���s�������>�� <�29�2E�w�{�{�:�.�.�.�4�H�-�c�H�E�E�E�K�%�+�+�-�-�� )�� )���A��"�"�1�a�(�(�(�(����~�~����*�.�.�)=�>�>��;��*�.�.�)9�:�:���� ����6�6���v�t�{�3�3���v�t�{�3�3���T�4�9�-�-�� �W������� r1���c�����������������������|�j��������������������������������������������D�]B\��}}|��������������������������������������������������������|�����������������������������������������������r|c�S��Ct ����������d���������������������|�������������������������)z~ Returns the appropriate connection adapter for the given URL. :rtype: requests.adapters.BaseAdapter z*No connection adapters were found for {!r})r����r4����lowerrw���r���ru���)rK���rk����prefixr����s��� r/���r����zSession.get_adapter���sz�������"&��!4�!4�!6�!6�� �� ��V�W��y�y�{�{�%�%�f�l�l�n�n�5�5�� ����� ���H�O�O�PS�T�T�U�U�Ur1���c������������������f�����|�j��������������������������������������������D�]}|�������������������������������������dS�)z+Closes all adapters and as such the sessionN)r�����valuesrv���)rK���r.���s��� r/���rv���z Session.close���s8��������%�%�'�'�� �� �A� �G�G�I�I�I�I� �� r1���c������������������������||�j����������<����fd�|�j���������D���������������}|D�]$}|�j������������������������������|������������|�j���������|<����%dS�)zwRegisters a connection adapter to a prefix. Adapters are sorted in descending order by prefix length. c������������������T������g�|�]$}t����������|������������t�����������������������k������"|��%S�r+���)rs���)r,���r-���r����s��� �r/���r0���z!Session.mount.<locals>.<listcomp>���s/�������I�I�I�a�C��F�F�S��[�[�4H�4H��4H�4H�4Hr1���N)r����r����)rK���r����r�����keys_to_mover:���s��� ` r/���r����z Session.mount���sd������� �!(�� �f��I�I�I�I�4�=�I�I�I���� 8�� 8�C�!%��!2�!2�3�!7�!7�D�M�#��� 8�� 8r1���c������������������.���������fd���j���������D���������������}|S�)Nc������������������4������i�|�]}|t�����������|d���������������S�r*���)�getattr)r,����attrrK���s��� �r/���� <dictcomp>z(Session.__getstate__.<locals>.<dictcomp>���s'�������L�L�L�T��w�t�T�4�0�0�L�L�Lr1���)� __attrs__)rK����states���` r/����__getstate__zSession.__getstate__���s#�������L�L�L�L�T�^�L�L�L���r1���c������������������\�����|������������������������������������D�]\��}}t����������|�||��������������d�S�r*���)r4����setattr)rK���r ��r���values��� r/����__setstate__zSession.__setstate__���s<������ �;�;�=�=�� '�� '�K�D�%��D�$��&�&�&�&� '�� 'r1���)NNNNNNNTNNNNNNr����r*���)r����r����r�����__doc__r ��r����r����r����r����r����r>���r����r����r����r����r����r����r����r����r����rv���r����r��r��r+���r1���r/���r����r����Q��s����������������$�����I�<-��<-��<-�|����������&��&��&�R�GK�CG�BF�J��J��J��J�X 2�� 2�� 2� 6�� 6�� 6� 3�� 3�� 3�I��I��I��I� =�� =�� =�� =� ?�� ?�� ?�� ?�5��5��5�I��I��I�V�����:V��V��V������ 8�� 8�� 8������'��'��'��'��'r1���r����c������������������������t������������������������S�)aZ�� Returns a :class:`Session` for context-management. .. deprecated:: 1.0.0 This method has been deprecated since version 1.0.0 and is only kept for backwards compatibility. New code should use :class:`~requests.sessions.Session` to create a session. This may be removed at a future date. :rtype: Session )r����r+���r1���r/����sessionr����s��������9�9�r1���)?r��r�����sys�time�datetimer����collectionsr���r����r����compatr���r���r ���r ���r���r����r���r ���r���r����modelsr���r���r���r����r���r����_internal_utilsr����utilsr���r���r���� exceptionsr���r���r���r���� structuresr���r����r���r���r ���r!���r"���r#���r$����status_codesr%���r&����platform�perf_counterr�����AttributeError�clockr;���rA����objectrC���r����r��r+���r1���r/����<module>r#�����s&�������� � � � �� � � � �������������������#��#��#��#��#��#��!��!��!��!��!��!��A��A��A��A��A��A��A��A��A��A��A��A��A��A�S��S��S��S��S��S��S��S��S��S��S��S��D��D��D��D��D��D��D��D��D��D��/��/��/��/��/��/��/��/��-��-��-��-��-��-��B��B��B��B��B��B��B��B��B��B�Q��Q��Q��Q��Q��Q��Q��Q��Q��Q��Q��Q��,��+��+��+��+��+��!��!��!��!��!��!�������������������������������� � ������������#��"��"��"��"��"���<�7���%��+������%��%��%��*����%������i�O��@K���������>�:E��C��C��C��C�n)��n)��n)��n)��n)�6��n)��n)��n)�bm'��m'��m'��m'��m'�"��m'��m'��m'�` ��������s����B%��%B4�3B4