� ���g�Y����ddlmZddlZddlZddlZddlZddlmZddlm Z ddl m Z m Z ddl mZddlmZdd lmZmZmZdd lmZmZmZmZdd lmZdd lmZdd lmZddl m!Z!ddl"m#Z#ddl$m%Z%m&Z&ej'r ddl(Z(ddl)m*Z*gd�Z+ej,e-��Z.dZ/dZ0Gd�dej1��Z2d'd�Z3ej4e3e2��ej4e3e2��d�Z5eed�Z6Gd�de��Z7Gd �d!e7��Z8d(d&�Z9dS))�)� 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�6�eZdZUdZded<ded<ded<ded<d ed <d ed <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.<d/S)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_retriesz bool | 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__���c/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/urllib3/poolmanager.pyr*r*8st����������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�*�*�*�*�&�&�&�&�#�#�#�#������rTr*� key_class� type[PoolKey]�request_context�dict[str, typing.Any]�returnc�X�|���}|d���|d<|d���|d<dD]8}||vr2||�*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_rMrS) �copy�lower� frozenset�items�get�tuple�list�keys�pop�_fields�_DEFAULT_BLOCKSIZE)rVrX�context�key� socket_opts�fields rU�_default_key_normalizerrr_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� � �rT��http�httpsc���eZdZUdZdZded<dZded< d<d=�fd� Zd>d�Zd?d�Z d@dAd"�Z dBd#�Z dCdDd(�Z dEd*�Z dFd-�Z d@dGd/�ZdHd1�ZdId5�Z dJdKd;�Z�xZS)LraV 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_config� � num_pools�intr^�typing.Mapping[str, str] | None�connection_pool_kw� typing.AnyrZ�Nonec ����t���|��||_|t|��|_t |_t ���|_dS�N)�super�__init__r}r�pools�pool_classes_by_scheme�key_fn_by_schemerc)�selfrzr^r}� __class__s �rUr�zPoolManager.__init__�s^��� ������!�!�!�"4��� �F�*�9�5�5�� �'=��#� 0� 5� 5� 7� 7����rTrc��|Sr�rS�r�s rU� __enter__zPoolManager.__enter__�s��� rT�exc_type�type[BaseException] | None�exc_val�BaseException | None�exc_tb�TracebackType | None�typing.Literal[False]c�.�|���dS)NF)�clear)r�r�r�r�s rU�__exit__zPoolManager.__exit__�s�� � � � � � ��urTr\r+r]�portrX�dict[str, typing.Any] | Noner c�&�|j|}|�|j���}|�d��� t|d<dD]}|�|d���|dkr 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)r\r]r�rt)r�r}rcrgrmrk� SSL_KEYWORDS)r�r\r]r�rX�pool_clsro�kws rU� _new_poolzPoolManager._new_pool�s��� .2�-H��-P�� � "�"�5�:�:�<�<�O� � � �{� +� +� 3�+=�O�K� (� .� +� +�C� � � ��T� *� *� *� *� �V� � �"� .� .���#�#�B��-�-�-�-��x��d�6�6�o�6�6�6rTc�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 rUr�zPoolManager.clear s�� � �������rTrtr4r.� pool_kwargsc���|std���|�|��}|pd|d<|s-tj|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.rtr\�Pr�r])r�_merge_pool_kwargsr rgrd�connection_from_context)r�r]r�r\r�rXs rU�connection_from_hostz PoolManager.connection_from_hosts���"� ;�$�%9�:�:� :��1�1�+�>�>��$*�$4�f���!�� M�!�%�o�h�&?�&E�&E�&G�&G��L�L�D�"&����"&�����+�+�O�<�<�<rTrYc�6�d|vr/tjdt��|�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.r\�rX) �warnings�warn�DeprecationWarningrkrdr�rgr�connection_from_pool_key)r�rXr\�pool_key_constructor�pool_keys rUr�z#PoolManager.connection_from_context1s��� �� &� &� �M�>�"� � � � � � �� )� )� )� ��*�0�0�2�2��#�4�8�8��@�@��#� +�"�6�*�*� *�'�'��8�8���,�,�X��,�W�W�WrTr�r*c��|jj5|j�|��}|r|cddd��S|d}|d}|d}|�||||���}||j|<ddd��n #1swxYwY|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. Nr\r]r�r�)r��lockrgr�)r�r�rX�poolr\r]r�s rUr�z$PoolManager.connection_from_pool_keyJs����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�r\r�)rr�r]r�r\)r�r�r��us rU�connection_from_urlzPoolManager.connection_from_urlds;�� �c�N�N���(�(� �F�����k�)� � � rT�overridec��|j���}|r6|���D]!\}}|� ||=� #t$rY�wxYw|||<�"|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}rcrf�KeyError)r�r��base_pool_kwargsro�values rUr�zPoolManager._merge_pool_kwargsvs��� �2�7�7�9�9�� � 2�&�n�n�.�.� 2� 2� ��U��=��,�S�1�1��#����������-2�$�S�)�)��s�<� A �A � parsed_urlr�boolc�V�|j�dSt|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)rwrrxr\)r�r�s rU�!_proxy_requires_url_absolute_formz-PoolManager._proxy_requires_url_absolute_form�s7�� �:� ��5�2� �J��)�:�+<� � � � rTT�method�redirectr�rc ��t|��}|j�tjdtd���|�|j|j|j���}d|d<d|d<d |vr |j|d <|� |��r|j ||fi|��}n|j ||j fi|��}|o|� ��}|s|St||��}|jd kr1d }d|d <t|d �����|d <|�d ��} t%| t&��st'j| |���} | jrp|�|��s[|d ���} |d D]3} | ���| jvr| �| d���4| |d < | �||||���} n.#t6$r!| jr|����|cYSwxYw| |d <||d<t<�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�r\F�assert_same_hostr�r^i/�GET�body�retries)r�)�response�_poolzRedirecting %s -> %s) rr\r�r�r�r�r]r�r^r��urlopen� request_uri�get_redirect_locationr�statusr�_prepare_for_method_changerg� isinstancer�from_int�remove_headers_on_redirect� is_same_hostrcrdrk� incrementr�raise_on_redirect� drain_conn�log�info) r�r�r�r�r�r��connr��redirect_locationr�� new_headers�headers rUr�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��B�v�J�*�2�i�=�9�9�T�T�V�V�B�y�M��&�&��#�#���'�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� G#�#(H� H)ryN)rzr{r^r|r}r~rZr)rZr)r�r�r�r�r�r�rZr�r�) r\r+r]r+r�r{rXr�rZr )rZr�NrtN� r]r4r�r.r\r4r�r�rZr )rXrYrZr )r�r*rXrYrZr )r�r+r�r�rZr )r�r�rZrY)r�rrZr��T� r�r+r�r+r�r�r�r~rZr)rNrOrPrQrwrRrxr�r�r�r�r�r�r�r�r�r�r�r�� __classcell__�r�s@rUrr�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����6EI� � � � � �$ � � � �,  �  �  �  �7;�P=�P=�P=�P=�P=�P=�P=�P=�P=rTrc�d��eZdZdZ d+d,�fd� Z d-d.�fd!� Z d/d0d$�Z d1d2�fd*� Z�xZS)3ra> 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 ryNF� proxy_urlr+rzr{r^r|� proxy_headers�proxy_ssl_contextr?�use_forwarding_for_httpsr��proxy_assert_hostname�"None | str | typing.Literal[False]�proxy_assert_fingerprintr4r}r~rZrc  ����t|t��r|j�d|j�d|j��} n|} t | ��} | jdvrt | j���| js0tj| jd��} | � | ���} | |_ |pi|_ ||_ t||||��|_|j | d<|j | d<|j| d<t��j||fi| ��dS) Nz://�:rsr�)r��_proxyr_� _proxy_config)r�r r\r]r�rrr rg�_replacerwr�r�r rxr�r�)r�r�rzr^r�r�r�r�r�r}� str_proxy_urlrwr�r�s �rUr�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�BrTrtr]r�r.r\r�r�r c����|dkr%t���||||���St���|jj|jj|jj|���S)Nru)r�)r�r�rwr]r�r\)r�r]r�r\r�r�s �rUr�z!ProxyManager.connection_from_hostLss��� �W� � ��7�7�/�/��d�F� �0��� ��w�w�+�+� �J�O�T�Z�_�d�j�.?�[�,� � � rTr��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 rU�_set_proxy_headerszProxyManager._set_proxy_headers\sM���e�$���3���&�� � &�%�H�V� � � %� �O�O�G� $� $� $��rTTr�r�r�rc ���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�) rrrwrxr\rgr^r�r�r�)r�r�r�r�r�r�r^r�s �rUr�zProxyManager.urlopenms���� �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�DrT)ryNNNFNN)r�r+rzr{r^r|r�r|r�r?r�r�r�r�r�r4r}r~rZrr�r�r�)r�r+r^r|rZr�r�r�) rNrOrPrQr�r�r�r�r�r�s@rUrr�s��������4�4�r�37�9=�37�).�DH�/3�'C�'C�'C�'C�'C�'C�'C�X �#�48�  � � � � � � �"DH������$7;� E� E� E� E� E� E� E� E� E� E� ErTrr�r+r�r~c ��tdd|i|��S)Nr�rS)r)r�r�s rUrr|s�� � ,� ,�#� ,�� ,� ,�,rT)rVrWrXrYrZr*)r�r+r�r~rZr):� __future__r� functools�logging�typingr��typesr� urllib.parser� _collectionsrr�_request_methodsr � connectionr �connectionpoolr r r � exceptionsrrrrr�r�util.connectionr� util.proxyr� util.retryr� util.timeoutr�util.urlrr� TYPE_CHECKING�ssl�typing_extensionsr�__all__� getLoggerrNr�r�rm� NamedTupler*rr�partialr�r�rrrrSrTrU�<module>rs���"�"�"�"�"�"��������� � � � ����������� � � � � � �?�?�?�?�?�?�?�?�,�,�,�,�,�,�#�#�#�#�#�#�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��$�$�$�N4 �4 �4 �4 �x �I� �5�w� ?� ?� �Y� �6�� @� @���� #5�?R�S�S��G=�G=�G=�G=�G=�.�G=�G=�G=�T ME�ME�ME�ME�ME�;�ME�ME�ME�`-�-�-�-�-�-rT
Memory