OwlCyberSecurity - MANAGER
Edit File: poolmanager.cpython-312.pyc
� ����W��g�Y��������������������������d�dl�mZ�d�dlZd�dlZd�dlZd�dlZd�dlmZ�d�dlm Z �ddl mZmZ�ddl mZ�ddlmZ�dd lmZmZmZ�dd lmZmZmZmZ�ddlmZ�ddlmZ�dd lmZ�ddl m!Z!�ddl"m#Z#�ddl$m%Z%m&Z&�ejN������������������r d�dl(Z(d�dl)m*Z*�g�d�Z+�ejX������������������e-�������Z.dZ/dZ0�G�d��dejb�������������������������Z2 � � � � � �dd�Z3�ejh������������������e3e2��������ejh������������������e3e2�������d�Z5eed�Z6�G�d��de�������Z7�G�d��de7�������Z8dd�Z9y) �����)�annotationsN)� TracebackType)�urljoin����)�HTTPHeaderDict�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)�Self)�PoolManager�ProxyManager�proxy_from_url)�key_file� cert_file� cert_reqs�ca_certs�ca_cert_data�ssl_version�ssl_minimum_version�ssl_maximum_version�ca_cert_dir�ssl_context�key_password�server_hostnamei�@��c�������������������4����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!<���d"ed#<���d ed$<���d%ed&<���d'ed(<���d ed)<���d*ed+<���ded,<���ded-<���ded.<���y/)0�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_certszstr | bytes | None�key_ca_cert_datazint | 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__��������B/opt/hc_python/lib/python3.12/site-packages/urllib3/poolmanager.pyr*���r*���8���s����������O��M���-�-�*�*���.�.��� � �������(�(�%�%�2�2�2�2���*�*���2�2���9�9�)�)�3�3�9�9�*�*�&�&�#�#��rT���r*���c���������������������|j��������������������������}|d���j��������������������������|d<���|d���j��������������������������|d<���dD�],��}||v�s�||�����t��������||���j���������������������������������||<����.�|j ������������������d�������}|�t��������|�������|d<���t ��������|j���������������������������������D�]��}|j������������������|�������|d|z���<�����|�j������������������D�]��}||vs�d||<�����|j ������������������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_rM���rS���)�copy�lower� frozenset�items�get�tuple�list�keys�pop�_fields�_DEFAULT_BLOCKSIZE)� key_class�request_context�context�key�socket_opts�fields��� rU����_default_key_normalizerro���_���s�����.��"�"�$�G���)�/�/�1�G�H���f�o�+�+�-�G�F�O��?���'�>�g�c�l�6�$�W�S�\�%7�%7�%9�:�G�C�L��?���+�+�.�/�K���$)�+�$6�� �!���G�L�L�N�#�� '���C� 0�������$���"�"�����!�G�E�N��#� ��{�{�?�#�+�#5��� ���w��rT�����http�httpsc�������������������.������e�Zd�ZU�dZdZded<���dZded<��� � �d � � � � � � �d��fd� Zdd�Z � � � � � � � �dd �Z �d � � � � � � � � �dd �Z dd�Z � � �d � � � � � � � � �dd�Z � � � �dd �Z � � � � � �dd�Z �d � � � � �dd�Z � � � �dd�Zd d�Z �d! � � � � � � � � �d"d�Z��xZS�)#r���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 NrC����proxyrF����proxy_configc�����������������������t����������|����|��������||�_��������|��t��������|�������|�_��������t ��������|�_��������t��������j��������������������������|�_��������y��N)�super�__init__�connection_pool_kwr����pools�pool_classes_by_scheme�key_fn_by_schemer^���)�self� num_poolsrY���rz���� __class__s��� �rU���ry���zPoolManager.__init__����sD�������� ����!�"4����*�9�5�� ��'=��#� 0� 5� 5� 7��rT���c����������������������|�S�rw���rS����r~���s��� rU���� __enter__zPoolManager.__enter__����s�������rT���c�����������������$�����|�j���������������������������y)NF)�clear)r~����exc_type�exc_val�exc_tbs��� rU����__exit__zPoolManager.__exit__����s������� � � ��rT���c���������������������|�j�������������������|���}|�|�j������������������j��������������������������}|j������������������d�������� t��������|d<���dD�]��}|j������������������|d����������|dk(��rt��������D�]��}|j������������������|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)rW���rX����portrq���)r|���rz���r^���rb���rh���rf����SSL_KEYWORDS)r~���rW���rX���r����rj����pool_clsrl����kws��� rU���� _new_poolzPoolManager._new_pool����s������� �.2�-H�-H��-P���"�"�5�5�:�:�<�O�����{�+�3�+=�O�K�(��.�C�����T�*��.���V��"���#�#�B��-��#����d�6�o�6�6rT���c�����������������8�����|�j�������������������j���������������������������y)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��� rU���r����zPoolManager.clear��s������� � � ���rT���c�����������������������|st��������d��������|�j������������������|�������}|xs�d|d<���|s't��������j������������������|d���j ��������������������������d�������}||d<���||d<���|�j������������������|�������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.rq���rW����P���r����rX���)r����_merge_pool_kwargsr ���rb���r_����connection_from_context)r~���rX���r����rW����pool_kwargsrj���s��� rU����connection_from_hostz PoolManager.connection_from_host��sz������"��$�%9�:�:��1�1�+�>��$*�$4�f���!��!�%�%�o�h�&?�&E�&E�&G��L�D�"&����"&�����+�+�O�<�<rT���c���������������������d|v�r+t��������j������������������dt����������������|j������������������d��������|d���j ��������������������������}|�j ������������������j ������������������|�������}|st��������|���������||�������}|�j������������������||��������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.rW����rj���) �warnings�warn�DeprecationWarningrf���r_���r}���rb���r����connection_from_pool_key)r~���rj���rW����pool_key_constructor�pool_keys��� rU���r����z#PoolManager.connection_from_context1��s����������&��M�M�>�"� � � ����)� ��*�0�0�2��#�4�4�8�8��@��#�"�6�*�*�'��8���,�,�X��,�W�WrT���c���������������������|�j�������������������j������������������5��|�j�������������������j������������������|�������}|r|cddd��������S�|d���}|d���}|d���}|�j������������������||||��������}||�j�������������������|<���ddd��������|S�#�1�sw�Y���S�xY�w)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. NrW���rX���r����r����)r{����lockrb���r����)r~���r����rj����poolrW���rX���r����s��� rU���r����z$PoolManager.connection_from_pool_keyJ��s���������Z�Z�_�_���:�:�>�>�(�+�D�����_��%�X�.�F�"�6�*�D�"�6�*�D��>�>�&�$��o�>�V�D�#'�D�J�J�x� �����������s����A=��3A=�=Bc�����������������~�����t��������|�������}|�j������������������|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����rW���r����)r���r����rX���r����rW���)r~����urlr�����us��� rU����connection_from_urlzPoolManager.connection_from_urld��s:������� �c�N���(�(� �F�F�������k��)�� �� rT���c����������������������|�j�������������������j��������������������������}|r$|j��������������������������D�]��\��}}|� �||=�� |||<�����|S�#�t��������$�r�Y��!w�xY�w)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. )rz���r^���ra����KeyError)r~����override�base_pool_kwargsrl����values��� rU���r����zPoolManager._merge_pool_kwargsv��sl������� �2�2�7�7�9���&�n�n�.� ��U��=��,�S�1��-2�$�S�)��/�� ��� �$�����s����A� A�Ac�����������������t�����|�j��������������������yt��������|�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. F)rt���r���ru���rW���)r~���� parsed_urls��� rU����!_proxy_requires_url_absolute_formz-PoolManager._proxy_requires_url_absolute_form���s:��������:�:���2��J�J��)�)�:�+<�+<� �� �� rT���c���������������������t��������|�������}|j�������������������t��������j������������������dt��������d���������|�j������������������|j������������������|j������������������|j��������������������������}d|d<���d|d<���d |vr|�j������������������|d <���|�j������������������|�������r�|j������������������||fi�|��}n�|j������������������||j������������������fi�|��}|xr�|j��������������������������}|s|S�t��������||�������}|j������������������d k(��r&d}d|d<���t��������|d ����������j!��������������������������|d <���|j#������������������d �������} t%��������| t&���������������st'��������j(������������������| |��������} | j*������������������rb|j-������������������|�������sQ|d ���j/��������������������������} |d ���D�]1��}|j1��������������������������| j*������������������v�s� | j3������������������|d���������3�| |d <��� �| j5������������������||||��������} | |d <���||d<���t<��������j?������������������d||��������|j;����������������������������|�j������������������||fi�|��S�#�t6��������$�r"�| j8������������������r|j;�����������������������������|cY�S�w�xY�w)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����rW���F�assert_same_host�redirectrY���i/���GET�body�retries)r����)�response�_poolzRedirecting %s -> %s) r���rW���r����r����r����r����rX���r����rY���r�����urlopen�request_uri�get_redirect_locationr����statusr����_prepare_for_method_changerb���� isinstancer����from_int�remove_headers_on_redirect�is_same_hostr^���r_���rf���� incrementr����raise_on_redirect� drain_conn�log�info)r~����methodr����r����r����r�����connr�����redirect_locationr�����new_headers�headers��� rU���r����zPoolManager.urlopen���sI������ �c�N���8�8���M�M�A��,�� ���(�(����a�f�f�Q�X�X�(�N��!&������:���B�� �L�L�B�y�M��1�1�!�4�#�t�|�|�F�C�6�2�6�H�#�t�|�|�F�A�M�M�@�R�@�H�$�I��)G�)G�)I�� ��O��$�C�):�;���?�?�c�!��F��B�v�J�*�2�i�=�9�T�T�V�B�y�M��&�&��#���'�5�)��n�n�W�x�@�G� ��-�-�d�6G�6G��7 ���Y�-�,�,�.�K��Y�-���<�<�>�W�%G�%G�G��O�O�F�D�1��(��(�B�y�M� ��'�'���h�d�'�S�G�� ��9� �!��:�����'��.?�@������t�|�|�F�$5�<��<�<����� ��(�(��#�#�%���O� �s����H!��!(I�I)� ���N)r����intrY����typing.Mapping[str, str] | Nonerz���� typing.Any�return�None)r����r���)r����ztype[BaseException] | Noner����zBaseException | Noner����zTracebackType | Noner����ztyping.Literal[False]rw���) rW���r+���rX���r+���r����r����rj����dict[str, typing.Any] | Noner����r���)r����r�����Nrq���N� rX���r4���r����r.���rW���r4���r����r����r����r���)rj����dict[str, typing.Any]r����r���)r����r*���rj���r����r����r���)r����r+���r����r����r����r���)r����r����r����r����)r����r���r�����bool�T� r����r+���r����r+���r����r����r����r����r����r���)rN���rO���rP���rQ���rt���rR���ru���ry���r����r����r����r����r����r����r����r����r����r����r����� __classcell__�r����s���@rU���r���r�������s��������B��E�:��'+�L�$�+���37�8��8��1�8��)� 8� � �8�"��,���&���%� � � ���9=�$7��$7���$7��� $7� �6�$7�� � $7�L�� �#�48�=��=���=��� =� �2�=�� � =�:X�4�X� �X�2���2G�� ��6�EI� �� �%A� � � �$ �4� � � �, ��7;�P=��P=� #�P=�/3�P=�BL�P=� �P=rT���r���c��������������������������e�Zd�ZdZ � � � � � � �d � � � � � � � � � � � � � � � � � � �d��fd� Z � � �d � � � � � � � � �d ��fd� Z �d � � � � �dd�Z �d � � � � � � � � �d ��fd� Z��xZS�)r���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 c �����������������(�����t��������|t���������������r)|j��������������������d|j��������������������d|j���������������������} n|} t��������| �������}|j������������������dvrt ��������|j��������������������������|j������������������s2t��������j������������������|j������������������d�������}|j������������������|��������}||�_ ��������|xs�i�|�_��������||�_��������t��������||||�������|�_��������|�j������������������| d<���|�j������������������| d<���|�j������������������| d<���t��������� |��@��||fi�| ���y�) Nz://�:rp���r����)r�����_proxyrZ���� _proxy_config)r����r���rW���rX���r����r���r���r ���rb����_replacert���� proxy_headers�proxy_ssl_contextr ���ru���rx���ry���)r~���� proxy_urlr���rY���r����r�����use_forwarding_for_https�proxy_assert_hostname�proxy_assert_fingerprintrz���� str_proxy_urlrt���r����r����s��� �rU���ry���zProxyManager.__init__#��s ��������i�!3�4�(�/�/�0��I�N�N�3C�1�Y�^�^�DT�U�M�%�M��-�(���<�<�0�0�$�U�\�\�2�2��z�z�!�%�%�e�l�l�B�7�D��N�N��N�-�E��� �*�0�b���!2���'��$�!�$� ����(,�z�z��8�$�/3�/A�/A��+�,�.2�.?�.?��?�+� ����G�B�/A�BrT���c������������������������|dk(��rt����������|����||||��������S�t����������|����|�j������������������j������������������|�j������������������j������������������|�j������������������j ������������������|��������S�)Nrr���)r����)rx���r����rt���rX���r����rW���)r~���rX���r����rW���r����r����s��� �rU���r����z!ProxyManager.connection_from_hostL��si���������W���7�/��d�F���0���� ���w�+��J�J�O�O�T�Z�Z�_�_�d�j�j�.?�.?�[��,�� �� rT���c�����������������l�����ddi}t��������|�������j������������������}|r||d<���|r|j������������������|��������|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����rY����headers_r����s��� rU����_set_proxy_headerszProxyManager._set_proxy_headers\��s>��������e�$���3��&�&���%�H�V����O�O�G�$��rT���c�����������������������t��������|�������}t��������|�j������������������|�j������������������|j�������������������������s1|j������������������d|�j�������������������������}|�j������������������||�������|d<���t���������|��$��||fd|i|��S�)z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.rY���r����) r���r���rt���ru���rW���rb���rY���r����rx���r����)r~���r����r����r����r����r����rY���r����s��� �rU���r����zProxyManager.urlopenm��so�������� �c�N��.�t�z�z�4�;L�;L�a�h�h�W���f�f�Y����5�G� �3�3�C��A�B�y�M��w��v�s�D�X�D��D�DrT���)r����NNNFNN)r����r+���r���r����rY���r����r����r����r����r?���r����r����r����z"None | str | typing.Literal[False]r����r4���rz���r����r����r����r����r����rw���)r����r+���rY���r����r����ztyping.Mapping[str, str]r����r����) rN���rO���rP���rQ���ry���r����r����r����r����r����s���@rU���r���r������s6������4�r��37�9=�37�).�DH�/3�'C��'C���'C��1� 'C� �7�'C��1� 'C��#'�'C�� B�'C��#-�'C��)�'C�� �'C�X� �#�48� �� ��� ��� � �2� �� � �"�DH����!@�� !��$�7;�E��E� #�E�/3�E�BL�E� �E��ErT���r���c����������������������t��������dd|�i|��S�)Nr����rS���)r���)r����r����s��� rU���r���r���|��s�������,�#�,��,�,rT���)ri���z type[PoolKey]rj���r����r����r*���)r����r+���r����r����r����r���):� __future__r���� functools�logging�typingr�����typesr����urllib.parser����_collectionsr���r����_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__� getLoggerrN���r����r����rh���� NamedTupler*���ro����partialr}���r|���r���r���r���rS���rT���rU����<module>r�����s�����"������ ������ ��?��,��#��S��S�����'��1��7����!��$� ����&� ;����g����!�� �� ����$�f����$�N4 ��4 �/D�4 ��4 �x� �I���5�w�?� �Y� � �6�� @���� �#5�?R�S���G=�.��G=�T ME�;��ME�`-rT���