관리-도구
편집 파일: poolmanager.cpython-38.pyc
U )�e�Y � @ s� d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm Z ddl m Z m Z ddl mZ ddlmZ dd lmZmZmZ dd lmZmZmZmZ dd lmZ dd l m Z dd l m Z ddl m!Z! ddl"m#Z# ddl$m%Z%m&Z& ej'r�d dl(Z(d dlm)Z) dddgZ*e�+e,�Z-dZ.dZ/e�0d�Z1G dd� dej2�Z3dddd �d d �Z4e�5e4e3�e�5e4e3�d �Z6eed �Z7G d d� de�Z8G d!d� de8�Z9d"d#dd$�d%d�Z:dS )&� )� 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)�Literal� PoolManager� ProxyManager�proxy_from_url) �key_file� cert_file� cert_reqs�ca_certs� ca_cert_data� ssl_versionZssl_minimum_versionZssl_maximum_version� ca_cert_dir� ssl_context� key_password�server_hostnamei @ �_SelfTc @ s� e Zd ZU dZded< ded< ded< ded< d ed < d ed < d ed< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded < d ed < 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_portz Timeout | 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 | NoneZkey_ca_cert_datazint | str | None�key_ssl_versionzssl.TLSVersion | NoneZkey_ssl_minimum_versionZkey_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__� rM rM �A/opt/hc_python/lib/python3.8/site-packages/urllib3/poolmanager.pyr' 9 s< r' z type[PoolKey]�dict[str, typing.Any])� key_class�request_context�returnc C s� |� � }|d �� |d< |d �� |d< dD ],}||kr,|| dk r,t|| �� �||< q,|�d�}|dk rxt|�|d< t|�� �D ]}|�|�|d| < q�| j D ]}||kr�d||< q�|�d�dkr�t |d< | f |�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_rG ) �copy�lower� frozenset�items�get�tuple�list�keys�pop�_fields�_DEFAULT_BLOCKSIZE)rP rQ �context�key� socket_opts�fieldrM rM rN �_default_key_normalizer` s" ri ��http�httpsc s e Zd ZU dZdZded< dZded< dAdd d d d �� fd d� Zddd�dd�Zddddd�dd�Z dBddddd d �d d �Z d d �d!d"�Z dCd$d%d$dd d&�d'd(�Z d)d d*�d+d,�Z d-d)d d.�d/d0�ZdDddd d1�d2d3�Zdd)d4�d5d6�Zd7d8d9�d:d;�ZdEddd8d d=d>�d?d@�Z� ZS )Fr 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 Nr= �proxyr@ � proxy_config� �int� typing.Mapping[str, str] | None� typing.Any�None)� num_poolsrU �connection_pool_kwrR c s4 t � �|� || _| t|�| _t| _t�� | _d S �N)�super�__init__ru r �pools�pool_classes_by_scheme�key_fn_by_schemerZ )�selfrt rU ru �� __class__rM rN rx � s zPoolManager.__init__r& )r| rR c C s | S rv rM �r| rM rM rN � __enter__� s zPoolManager.__enter__ztype[BaseException] | NonezBaseException | NonezTracebackType | NonezLiteral[False])�exc_type�exc_val�exc_tbrR c C s | � � dS )NF)�clear)r| r� r� r� rM rM rN �__exit__� s zPoolManager.__exit__r( � dict[str, typing.Any] | Noner )rS rT �portrQ rR c C st | j | }|dkr | j�� }|�d�dkr2t|d< dD ]}|�|d� q6|dkrftD ]}|�|d� qT|||f|�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)rS rT r� rk )rz ru rZ r^ rd rb � SSL_KEYWORDS)r| rS rT r� rQ �pool_clsrf �kwrM rM rN � _new_pool� s zPoolManager._new_pool)rR c C s | 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)ry r� r rM rM rN r� s zPoolManager.clearrk r1 r+ �rT r� rS � pool_kwargsrR c C sT |s t d��| �|�}|p d|d< |s:t�|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.rk rS �P r� rT )r �_merge_pool_kwargsr r^ r[ �connection_from_context)r| rT r� rS r� rQ rM rM rN �connection_from_host s z PoolManager.connection_from_hostrO )rQ rR c C sX d|kr t �dt� |�d� |d �� }| j�|�}|sBt|��||�}| j||d�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.rS �rQ ) �warnings�warn�DeprecationWarningrb r[ r{ r^ r �connection_from_pool_key)r| rQ rS �pool_key_constructor�pool_keyrM rM rN r� 2 s � z#PoolManager.connection_from_contextr' )r� rQ rR c C sl | j j�Z | j �|�}|r*|W 5 Q R � S |d }|d }|d }| j||||d�}|| j |< W 5 Q R X |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. rS rT r� r� )ry �lockr^ r� )r| r� rQ �poolrS rT r� rM rM rN r� K s z$PoolManager.connection_from_pool_key)�urlr� rR c C s t |�}| j|j|j|j|d�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� rS r� )r r� rT r� rS )r| r� r� �urM rM rN �connection_from_urle s �z PoolManager.connection_from_url)�overriderR c C sV | j �� }|rR|�� D ]:\}}|dkrHz ||= W qP tk rD Y qPX q|||< q|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. N)ru rZ r] �KeyError)r| r� �base_pool_kwargsrf �valuerM rM rN r� w s z PoolManager._merge_pool_kwargsr �bool)� parsed_urlrR c C s" | j dkrdS 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)rm r rn rS )r| r� rM rM rN �!_proxy_requires_url_absolute_form� s �z-PoolManager._proxy_requires_url_absolute_formTr ��methodr� �redirectr� rR c K s� t |�}|jdkr"tjdtdd� | j|j|j|jd�}d|d< d|d< d |krZ| j|d < | � |�rv|j ||f|�}n|j ||j f|�}|o�|� � }|s�|S t ||�}|jd kr�d }d|d < t|d ��� |d < |�d �} t| t�s�tj| |d�} | j�rF|�|��sF|d �� } |d D ]"} | �� | jk�r| �| d� �q| |d < z| j||||d�} W n, tk �r� | j �r�|� � � | Y S X | |d < ||d< t � d||� |� � | j ||f|�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� rS F�assert_same_hostr� rU i/ �GET�body�retries)r� )�response�_poolzRedirecting %s -> %s) r rS r� r� r� r� rT r� rU r� �urlopen� request_uri�get_redirect_locationr �statusr Z_prepare_for_method_changer^ � isinstancer �from_int�remove_headers_on_redirect� is_same_hostrZ r[ rb � incrementr �raise_on_redirect� drain_conn�log�info) r| r� r� r� r� r� �connr� �redirect_locationr� � new_headers�headerrM rM rN r� � s\ � � zPoolManager.urlopen)ro N)N)Nrk N)N)T)rH rI rJ rK rm rL rn rx r� r� r� r� r� r� r� r� r� r� r� � __classcell__rM rM r} rN r � s. ! � �& � � �c s� e Zd ZdZd!dddddd d d d d d� � fdd� Zd"d dd ddd�� fdd� Zd#dddd�dd�Zd$ddd d d d �� fd d � Z� ZS )%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 ro NFr( rp rq r9 r� zNone | str | Literal[False]r1 rr rs ) � proxy_urlrt rU � proxy_headers�proxy_ssl_context�use_forwarding_for_https�proxy_assert_hostname�proxy_assert_fingerprintru rR c s� t |t�r&|j� d|j� d|j� �} n|} t| �} | jdkrFt| j��| jsft�| jd�} | j | d�} | | _ |pri | _ || _ t ||||�| _| j | d< | j | d< | j| d< t� j||f| � d S ) Nz://�:rj r� )r� �_proxyrV � _proxy_config)r� r rS rT r� r r r r^ �_replacerm r� r� r rn rw rx ) r| r� rt rU r� r� r� r� r� ru Z str_proxy_urlrm r� r} rM rN rx $ s, � zProxyManager.__init__rk r+ r� r r� c s< |dkr t � j||||d�S t � j| jj| jj| jj|d�S )Nrl )r� )rw r� rm rT r� rS )r| rT r� rS r� r} rM rN r� M s � �z!ProxyManager.connection_from_hostztyping.Mapping[str, str])r� rU rR c C s0 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� rU �headers_r� rM rM rN �_set_proxy_headers] s z ProxyManager._set_proxy_headersTr r� c sR t |�}t| j| j|j�s8|�d| j�}| �||�|d< t� j ||fd|i|��S )z@Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.rU r� ) r r rm rn rS r^ rU r� rw r� )r| r� r� r� r� r� rU r} rM rN r� n s zProxyManager.urlopen)ro NNNFNN)Nrk N)N)T) rH rI rJ rK rx r� r� r� r� rM rM r} rN r � s" 9 �&, � � �r( rr )r� r� rR c K s t f d| i|��S )Nr� )r )r� r� rM rM rN r } s );� __future__r � functools�logging�typingr� �typesr � urllib.parser � _collectionsr r Z_request_methodsr � connectionr �connectionpoolr r r � exceptionsr r r r r� r Zutil.connectionr Z util.proxyr Z util.retryr Z util.timeoutr Zutil.urlr r � TYPE_CHECKING�sslr �__all__� getLoggerrH r� r� rd �TypeVarr& � NamedTupler' ri �partialr{ rz r r r rM rM rM rN �<module> sJ '< � L