OwlCyberSecurity - MANAGER
Edit File: poolmanager.cpython-311.pyc
� ������hxX��������������������������d�dl�mZ�d�dlZd�dlZd�dlZd�dlZd�dlmZ�d�dlm Z �ddl mZ�ddlm Z �ddlmZ�dd lmZmZmZ�dd lmZmZmZmZ�ddlmZ�ddlmZ�dd lmZ�ddlm Z �ddl!m"Z"�ddl#m$Z$m%Z%�ej&��������r d�dl'Z'd�dl(m)Z)�g�d�Z*�ej+��������e,������������Z-dZ.dZ/�ej0��������d������������Z1�G�d��dej2��������������������Z3d(d�Z4�ej5��������e4e3�������������ej5��������e4e3������������d�Z6eed�Z7�G�d��d e ������������Z8�G�d!��d"e8������������Z9d)d'�Z:dS�)*�����)�annotationsN)� TracebackType)�urljoin����)�RecentlyUsedContainer)�RequestMethods)�ProxyConfig)�HTTPConnectionPool�HTTPSConnectionPool�port_by_scheme)�LocationValueError� MaxRetryError�ProxySchemeUnknown�URLSchemeUnknown)�BaseHTTPResponse)�_TYPE_SOCKET_OPTIONS)�connection_requires_http_tunnel)�Retry)�Timeout)�Url� parse_url)�Literal)�PoolManager�ProxyManager�proxy_from_url)�key_file� cert_file� cert_reqs�ca_certs�ssl_version�ssl_minimum_version�ssl_maximum_version�ca_cert_dir�ssl_context�key_password�server_hostnamei�@���_SelfTc�������������������,����e�Zd�ZU�dZded<���ded<���ded<���ded<���d ed <���ded<���d ed<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���ded<���d ed!<���ded"<���d#ed$<���d%ed&<���ded'<���d(ed)<���ded*<���ded+<���ded,<���d-S�).�PoolKeyz� All known keyword arguments that could be provided to the pool manager, its pools, or the underlying connections. All custom key schemes should include the fields in this key at a minimum. �str� key_scheme�key_host� int | None�key_portzTimeout | float | int | None�key_timeoutzRetry | bool | int | None�key_retrieszbool | None� key_blockztuple[str, int] | None�key_source_address� str | None�key_key_file�key_key_password� key_cert_file� key_cert_reqs�key_ca_certszint | str | None�key_ssl_versionzssl.TLSVersion | None�key_ssl_minimum_version�key_ssl_maximum_version�key_ca_cert_dir�ssl.SSLContext | None�key_ssl_context�key_maxsizez!frozenset[tuple[str, str]] | None�key_headers� Url | None� key__proxy�key__proxy_headers�ProxyConfig | None�key__proxy_configz_TYPE_SOCKET_OPTIONS | None�key_socket_options�key__socks_optionszbool | str | None�key_assert_hostname�key_assert_fingerprint�key_server_hostname� key_blocksizeN)�__name__� __module__�__qualname__�__doc__�__annotations__��������J/opt/cloudlinux/venv/lib64/python3.11/site-packages/urllib3/poolmanager.pyr)���r)���9���sh��������������������O�O�O��M�M�M�����-�-�-�-�*�*�*�*�����.�.�.�.����� � � � �������������%�%�%�%�2�2�2�2�2�2�2�2�����*�*�*�*�����2�2�2�2�����9�9�9�9�)�)�)�)�3�3�3�3�9�9�9�9�*�*�*�*�&�&�&�&�#�#�#�#������rR���r)���� key_class� type[PoolKey]�request_context�dict[str, typing.Any]�returnc�����������������X����|������������������������������������}|d��������������������������������������������|d<���|d��������������������������������������������|d<���dD�]8}||v�r2||����������*t����������||��������������������������������������������������������||<����9|���������������������d������������}|�t����������|������������|d<���t ����������|�����������������������������������������������D�]}|���������������������|������������|d|z���<����|�j ��������D�]}||vrd||<����|���������������������d������������� t����������|d<����|�di�|��S�) a��� Create a pool key out of a request context dictionary. According to RFC 3986, both the scheme and host are case-insensitive. Therefore, this function normalizes both before constructing the pool key for an HTTPS request. If you wish to change this behaviour, provide alternate callables to ``key_fn_by_scheme``. :param key_class: The class to use when constructing the key. This should be a namedtuple with the ``scheme`` and ``host`` keys at a minimum. :type key_class: namedtuple :param request_context: A dictionary-like object that contain the context for a request. :type request_context: dict :return: A namedtuple that can be used as a connection pool key. :rtype: PoolKey �scheme�host)�headers�_proxy_headers�_socks_optionsN�socket_options�key_rK���rQ���)�copy�lower� frozenset�items�get�tuple�list�keys�pop�_fields�_DEFAULT_BLOCKSIZE)rT���rV����context�key�socket_opts�fields��� rS����_default_key_normalizerrp���_���sV�����.��"�"�$�$�G���)�/�/�1�1�G�H���f�o�+�+�-�-�G�F�O��?��;��;���'�>�>�g�c�l�6�$�W�S�\�%7�%7�%9�%9�:�:�G�C�L����+�+�.�/�/�K���$)�+�$6�$6�� �!���G�L�L�N�N�#�#��1��1�� '���C� 0� 0���������"��"��"������!�G�E�N����{�{�?�#�#�+�#5��� ��9���w���rR�����http�httpsc��������������������������e�Zd�ZU�dZdZded<���dZded<��� � �d=d>��fd� Zd?d�Zd@d�Z �dAdBd#�Z dCd$�Z � � �dDdEd)�ZdFd+�Z dGd.�Z �dAdHd0�ZdId2�ZdJd6�Z �dKdLd<�Z��xZS�)Mr���aV�� Allows for arbitrary requests while transparently keeping track of necessary connection pools for you. :param num_pools: Number of connection pools to cache before discarding the least recently used pool. :param headers: Headers to include with all requests, unless other headers are given explicitly. :param \**connection_pool_kw: Additional parameters are used to create fresh :class:`urllib3.connectionpool.ConnectionPool` instances. Example: .. code-block:: python import urllib3 http = urllib3.PoolManager(num_pools=2) resp1 = http.request("GET", "https://google.com/") resp2 = http.request("GET", "https://google.com/mail") resp3 = http.request("GET", "https://yahoo.com/") print(len(http.pools)) # 2 NrA����proxyrD����proxy_config� ���� num_pools�intr\����typing.Mapping[str, str] | None�connection_pool_kw� typing.AnyrX����Nonec������������������������t���������������������������������������������|�������������||�_��������|��t����������|������������|�_��������t ����������|�_��������t���������������������������������������������|�_��������d�S��N)�super�__init__r{���r����pools�pool_classes_by_scheme�key_fn_by_schemera���)�selfrx���r\���r{���� __class__s��� �rS���r����zPoolManager.__init__����s^�������� ������!�!�!�"4����F�*�9�5�5�� ��'=��#� 0� 5� 5� 7� 7����rR���r����r'���c����������������������|�S�r���rQ����r����s��� rS���� __enter__zPoolManager.__enter__����s�������rR����exc_type�type[BaseException] | None�exc_val�BaseException | None�exc_tb�TracebackType | None�Literal[False]c�����������������.�����|��������������������������������������dS�)NF)�clear)r����r����r����r����s��� rS����__exit__zPoolManager.__exit__����s������� � � �����urR���rZ���r*���r[����portrV����dict[str, typing.Any] | Noner ���c�����������������&����|�j���������|���������}|�|�j�������������������������������������������}|���������������������d������������� t����������|d<���dD�]}|���������������������|d��������������|dk����r t����������D�]}|���������������������|d���������������|||fi�|��S�)a��� Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and any additional pool keyword arguments. If ``request_context`` is provided, it is provided as keyword arguments to the pool class used. This method is used to actually create the connection pools handed out by :meth:`connection_from_url` and companion methods. It is intended to be overridden for customization. N� blocksize)rZ���r[���r����rr���)r����r{���ra���re���rk���ri����SSL_KEYWORDS)r����rZ���r[���r����rV����pool_clsrm����kws��� rS���� _new_poolzPoolManager._new_pool����s������� �.2�-H��-P���"�"�5�:�:�<�<�O�����{�+�+�3�+=�O�K�(��.�� +�� +�C�����T�*�*�*�*��V���"�� .�� .���#�#�B��-�-�-�-��x��d�6�6�o�6�6�6rR���c�����������������8�����|�j���������������������������������������������dS�)z� Empty our store of pools and direct them all to close. This will not affect in-flight connections, but they will not be re-used after completion. N)r����r����r����s��� rS���r����zPoolManager.clear��s������� � �������rR���rr���r3���r-����pool_kwargsc����������������������|st����������d�������������|����������������������|������������}|pd|d<���|s-t����������j��������|d��������������������������������������������d������������}||d<���||d<���|����������������������|������������S�)a��� Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme. If ``port`` isn't given, it will be derived from the ``scheme`` using ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is provided, it is merged with the instance's ``connection_pool_kw`` variable and used to create the new connection pool, if one is needed. zNo host specified.rr���rZ����P���r����r[���)r ����_merge_pool_kwargsr���re���rb����connection_from_context)r����r[���r����rZ���r����rV���s��� rS����connection_from_hostz PoolManager.connection_from_host��s�������"��� ;�$�%9�:�:�:��1�1�+�>�>��$*�$4�f���!��� M�!�%�o�h�&?�&E�&E�&G�&G��L�L�D�"&����"&�����+�+�O�<�<�<rR���rW���c�����������������6����d|v�r/t����������j��������dt�����������������������|���������������������d�������������|d��������������������������������������������}|�j�����������������������������|������������}|st����������|��������������||������������}|����������������������||�������������S�)z� Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context. ``request_context`` must at least contain the ``scheme`` key and its value must be a key in ``key_fn_by_scheme`` instance variable. �strictzdThe 'strict' parameter is no longer needed on Python 3+. This will raise an error in urllib3 v2.1.0.rZ����rV���) �warnings�warn�DeprecationWarningri���rb���r����re���r����connection_from_pool_key)r����rV���rZ����pool_key_constructor�pool_keys��� rS���r����z#PoolManager.connection_from_context1��s����������&�&��M�>�"� �� �� � � ����)�)�)� ��*�0�0�2�2��#�4�8�8��@�@��#�� +�"�6�*�*�*�'�'��8�8���,�,�X��,�W�W�WrR���r����r)���c���������������������|�j���������j��������5��|�j������������������������������|������������}|r|cddd�������������S�|d���������}|d���������}|d���������}|����������������������||||�������������}||�j���������|<���ddd�������������n#�1�swxY�w�Y���|S�)a�� Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key. ``pool_key`` should be a namedtuple that only contains immutable objects. At a minimum it must have the ``scheme``, ``host``, and ``port`` fields. NrZ���r[���r����r����)r�����lockre���r����)r����r����rV����poolrZ���r[���r����s��� rS���r����z$PoolManager.connection_from_pool_keyJ��s���������Z�_�� (�� (���:�>�>�(�+�+�D��� �� (�� (�� (�� (�� (�� (�� (�� (��%�X�.�F�"�6�*�D�"�6�*�D��>�>�&�$��o�>�V�V�D�#'�D�J�x� � (�� (�� (�� (�� (�� (�� (�� (�� (�� (�� (����� (�� (�� (�� (���s����A?�;A?�?B�B�urlc�����������������p�����t����������|������������}|����������������������|j��������|j��������|j��������|�������������S�)a��� Similar to :func:`urllib3.connectionpool.connection_from_url`. If ``pool_kwargs`` is not provided and a new pool needs to be constructed, ``self.connection_pool_kw`` is used to initialize the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs`` is provided, it is used instead. Note that if a new pool does not need to be created for the request, the provided ``pool_kwargs`` are not used. )r����rZ���r����)r���r����r[���r����rZ���)r����r����r�����us��� rS����connection_from_urlzPoolManager.connection_from_urld��s;������� �c�N�N���(�(� �F�����k��)�� �� �� rR����overridec����������������������|�j��������������������������������������������}|r6|�����������������������������������D�]!\��}}|� �||=��#�t����������$�r�Y��w�xY�w|||<����"|S�)a�� Merge a dictionary of override values for self.connection_pool_kw. This does not modify self.connection_pool_kw and returns a new dict. Any keys in the override dictionary with a value of ``None`` are removed from the merged dictionary. )r{���ra���rd����KeyError)r����r�����base_pool_kwargsrm����values��� rS���r����zPoolManager._merge_pool_kwargsv��s�������� �2�7�7�9�9���� 2�&�n�n�.�.�� 2�� 2� ��U��=��,�S�1�1��#��������������-2�$�S�)�)��s����<� A �A � parsed_urlr����boolc�����������������V�����|�j����������dS�t����������|�j���������|�j��������|j���������������������S�)z� Indicates if the proxy requires the complete destination URL in the request. Normally this is only needed when not using an HTTP CONNECT tunnel. NF)ru���r���rv���rZ���)r����r����s��� rS����!_proxy_requires_url_absolute_formz-PoolManager._proxy_requires_url_absolute_form���s7��������:���5�2��J��)�:�+<� �� �� �� rR���T�method�redirectr����r���c�����������������V����t����������|������������}|j���������t����������j��������dt����������d��������������|����������������������|j��������|j��������|j���������������������}d|d<���d|d<���d |vr |�j��������|d <���|�� ��������������������|������������r�|j ��������||fi�|��}n�|j ��������||j��������fi�|��}|o|�����������������������������������}|s|S�t����������||������������}|j��������d k����rd}|���������������������d������������} t!����������| t"����������������������st#����������j��������| |� ������������} | j��������rp|���������������������|������������s[|d ��������������������������������������������} |d ���������D�]3}|�����������������������������������| j��������v�r| ���������������������|d��������������4| |d <��� �| ���������������������||||�������������} n.#�t2����������$�r!�| j��������r|��������������������������������������|cY�S�w�xY�w| |d<���||d<���t8�������������������������������d||�������������|�������������������������������������|�j ��������||fi�|��S�)aN�� Same as :meth:`urllib3.HTTPConnectionPool.urlopen` with custom cross-host redirect logic and only sends the request-uri portion of the ``url``. The given ``url`` parameter must be absolute, such that an appropriate :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. Na ��URLs without a scheme (ie 'https://') are deprecated and will raise an error in a future version of urllib3. To avoid this DeprecationWarning ensure all URLs start with 'https://' or 'http://'. Read more in this issue: https://github.com/urllib3/urllib3/issues/2920����)�category� stacklevel)r����rZ���F�assert_same_hostr����r\���i/���GET�retries)r����)�response�_poolzRedirecting %s -> %s)r���rZ���r����r����r����r����r[���r����r\���r�����urlopen�request_uri�get_redirect_locationr����statusre���� isinstancer����from_int�remove_headers_on_redirect�is_same_hostra���rb���ri���� incrementr����raise_on_redirect� drain_conn�log�info)r����r����r����r����r����r�����connr�����redirect_locationr�����new_headers�headers��� rS���r����zPoolManager.urlopen���s������� �c�N�N���8���M�A��,�� �� �� �� ���(�(���a�f�Q�X�(�N�N��!&������:���B��� �L�B�y�M��1�1�!�4�4�� A�#�t�|�F�C�6�6�2�6�6�H�H�#�t�|�F�A�M�@�@�R�@�@�H�$�I��)G�)G�)I�)I�� �� ��O��$�C�):�;�;����?�c�!�!��F��&�&��#�#���'�5�)�)�� A��n�W�x�@�@�@�G� ��-�� (�d�6G�6G��7 ��7 �� (���Y�-�,�,�.�.�K��Y�-�� 2�� 2���<�<�>�>�W�%G�G�G��O�O�F�D�1�1�1��'�B�y�M� ��'�'���h�d�'�S�S�G�G���� �� �� ��(�� ��#�#�%�%�%���O�O�O� ����� ��9� �!��:�����'��.?�@�@�@��������t�|�F�$5�<�<��<�<�<s����F4��4(G�G)rw���N)rx���ry���r\���rz���r{���r|���rX���r}���)r����r'���rX���r'���)r����r����r����r����r����r����rX���r����r���) rZ���r*���r[���r*���r����ry���rV���r����rX���r ���)rX���r}����Nrr���N� r[���r3���r����r-���rZ���r3���r����r����rX���r ���)rV���rW���rX���r ���)r����r)���rV���rW���rX���r ���)r����r*���r����r����rX���r ���)r����r����rX���rW���)r����r���rX���r�����T� r����r*���r����r*���r����r����r����r|���rX���r���)rL���rM���rN���rO���ru���rP���rv���r����r����r����r����r����r����r����r����r����r����r����r����� __classcell__�r����s���@rS���r���r�������s��������������������B��E�����'+�L�+�+�+�+���37�8��8��8��8��8��8��8�"���������������9=�$7��$7��$7��$7��$7�L�������� �#�48�=��=��=��=��=�:X��X��X��X�2�������6�EI� �� �� �� �� �$ �� �� �� �, �� �� �� ��7;�M=��M=��M=��M=��M=��M=��M=��M=��M=rR���r���c�������������������d�������e�Zd�ZdZ � � � � � � �d+d,��fd� Z � � �d-d.��fd!� Z �d/d0d$�Z �d1d2��fd*� Z��xZS�)3r���a>�� Behaves just like :class:`PoolManager`, but sends all requests through the defined proxy, using the CONNECT method for HTTPS URLs. :param proxy_url: The URL of the proxy to be used. :param proxy_headers: A dictionary containing headers that will be sent to the proxy. In case of HTTP they are being sent with each request, while in the HTTPS/CONNECT case they are sent only once. Could be used for proxy authentication. :param proxy_ssl_context: The proxy SSL context is used to establish the TLS connection to the proxy when using HTTPS proxies. :param use_forwarding_for_https: (Defaults to False) If set to True will forward requests to the HTTPS proxy to be made on behalf of the client instead of creating a TLS tunnel via the CONNECT method. **Enabling this flag means that request and response headers and content will be visible from the HTTPS proxy** whereas tunneling keeps request and response headers and content private. IP address, target hostname, SNI, and port are always visible to an HTTPS proxy even when this flag is disabled. :param proxy_assert_hostname: The hostname of the certificate to verify against. :param proxy_assert_fingerprint: The fingerprint of the certificate to verify against. Example: .. code-block:: python import urllib3 proxy = urllib3.ProxyManager("https://localhost:3128/") resp1 = proxy.request("GET", "https://google.com/") resp2 = proxy.request("GET", "https://httpbin.org/") print(len(proxy.pools)) # 1 resp3 = proxy.request("GET", "https://httpbin.org/") resp4 = proxy.request("GET", "https://twitter.com/") print(len(proxy.pools)) # 3 rw���NF� proxy_urlr*���rx���ry���r\���rz���� proxy_headers�proxy_ssl_contextr=����use_forwarding_for_httpsr�����proxy_assert_hostname�None | str | Literal[False]�proxy_assert_fingerprintr3���r{���r|���rX���r}���c ����������������������t����������|t����������������������r|j����������d|j����������d|j�����������} n|} t����������| ������������}|j��������dvrt ����������|j���������������������|j��������s0t����������j��������|j��������d������������}|� ��������������������|�������������}||�_ ��������|pi�|�_��������||�_��������t����������||||������������|�_��������|�j ��������| d<���|�j��������| d<���|�j��������| d<����t������������������������j��������||fi�| ���d�S�) Nz://�:rq���r����)r�����_proxyr]���� _proxy_config)r����r ���rZ���r[���r����r���r���r���re����_replaceru���r����r����r ���rv���r����r����)r����r����rx���r\���r����r����r����r����r����r{���� str_proxy_urlru���r����r����s��� �rS���r����zProxyManager.__init__ ��s+��������i�!3�4�4�� &�(�/�U�U�I�N�U�U�Y�^�U�U�M�M�%�M��-�(�(���<�0�0�0�$�U�\�2�2�2��z�� .�!�%�e�l�B�7�7�D��N�N��N�-�-�E��� �*�0�b���!2���'��$�!�$� �� ����(,�z��8�$�/3�/A��+�,�.2�.?��?�+�������G�B�B�/A�B�B�B�B�BrR���rr���r[���r����r-���rZ���r����r����r ���c������������������������|dk����r%t���������������������������������������������||||�������������S�t���������������������������������������������|�j��������j��������|�j��������j��������|�j��������j��������|�������������S�)Nrs���)r����)r����r����ru���r[���r����rZ���)r����r[���r����rZ���r����r����s��� �rS���r����z!ProxyManager.connection_from_hostI��ss���������W����7�7�/�/��d�F���0������ ���w�w�+�+��J�O�T�Z�_�d�j�.?�[��,�� �� �� rR���r�����typing.Mapping[str, str]c�����������������r�����ddi}t����������|������������j��������}|r||d<���|r|���������������������|�������������|S�)z� Sets headers needed by proxies: specifically, the Accept and Host headers. Only sets headers not provided by the user. �Acceptz*/*�Host)r����netloc�update)r����r����r\����headers_r����s��� rS����_set_proxy_headerszProxyManager._set_proxy_headersY��sM��������e�$���3���&���� &�%�H�V���� %��O�O�G�$�$�$��rR���Tr����r����r����r���c����������������������t����������|������������}t����������|�j��������|�j��������|j��������������������s4|���������������������d|�j��������������������}|����������������������||������������|d<����t������������������������j ��������||fd|i|��S�)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.r\���r����) r���r���ru���rv���rZ���re���r\���r����r����r����)r����r����r����r����r����r����r\���r����s��� �rS���r����zProxyManager.urlopenj��s��������� �c�N�N��.�t�z�4�;L�a�h�W�W�� B���f�f�Y���5�5�G� �3�3�C��A�A�B�y�M��u�w�w��v�s�D�D�X�D��D�D�DrR���)rw���NNNFNN)r����r*���rx���ry���r\���rz���r����rz���r����r=���r����r����r����r����r����r3���r{���r|���rX���r}���r����r����r���)r����r*���r\���rz���rX���r����r����r����) rL���rM���rN���rO���r����r����r����r����r����r����s���@rS���r���r������s����������������4��4�r��37�9=�37�).�=A�/3�'C��'C��'C��'C��'C��'C��'C�X� �#�48� �� �� �� �� �� �� �"�DH����������$�7;�E��E��E��E��E��E��E��E��E��E��ErR���r���r����r*���r����r|���c����������������������t����������dd|�i|��S�)Nr����rQ���)r���)r����r����s��� rS���r���r���y��s�������,�,�#�,��,�,�,rR���)rT���rU���rV���rW���rX���r)���)r����r*���r����r|���rX���r���);� __future__r���� functools�logging�typingr�����typesr����urllib.parser����_collectionsr����_request_methodsr���� connectionr ����connectionpoolr ���r���r���� exceptionsr ���r���r���r���r����r����util.connectionr���� util.proxyr���� util.retryr����util.timeoutr����util.urlr���r���� TYPE_CHECKING�ssl�typing_extensionsr����__all__� getLoggerrL���r����r����rk����TypeVarr'���� NamedTupler)���rp����partialr����r����r���r���r���rQ���rR���rS����<module>r�����s������"��"��"��"��"��"��������������� � � � ������������������� �� �� �� �� �� ��/��/��/��/��/��/��,��,��,��,��,��,��#��#��#��#��#��#��S��S��S��S��S��S��S��S��S��S�������������������������'��&��&��&��&��&��1��1��1��1��1��1��7��7��7��7��7��7��������������!��!��!��!��!��!��$��$��$��$��$��$��$��$� ���*��J�J�J�)�)�)�)�)�)� ;� ;� ;����g���!�!�������� ���� !� !��#��#��#��#��#�f���#��#��#�L4 ��4 ��4 ��4 �x� �I��5�w�?�?� �Y� �6�� @� @������ �#5�?R�S�S���D=��D=��D=��D=��D=�.��D=��D=��D=�N ME��ME��ME��ME��ME�;��ME��ME��ME�`-��-��-��-��-��-rR���