structures.py 0000644 00000005645 15173103334 0007353 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
"""
from .compat import OrderedDict, Mapping, MutableMapping
class CaseInsensitiveDict(MutableMapping):
"""A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
"""
def __init__(self, data=None, **kwargs):
self._store = OrderedDict()
if data is None:
data = {}
self.update(data, **kwargs)
def __setitem__(self, key, value):
# Use the lowercased key for lookups, but store the actual
# key alongside the value.
self._store[key.lower()] = (key, value)
def __getitem__(self, key):
return self._store[key.lower()][1]
def __delitem__(self, key):
del self._store[key.lower()]
def __iter__(self):
return (casedkey for casedkey, mappedvalue in self._store.values())
def __len__(self):
return len(self._store)
def lower_items(self):
"""Like iteritems(), but with all lowercase keys."""
return (
(lowerkey, keyval[1])
for (lowerkey, keyval)
in self._store.items()
)
def __eq__(self, other):
if isinstance(other, Mapping):
other = CaseInsensitiveDict(other)
else:
return NotImplemented
# Compare insensitively
return dict(self.lower_items()) == dict(other.lower_items())
# Copy is required
def copy(self):
return CaseInsensitiveDict(self._store.values())
def __repr__(self):
return str(dict(self.items()))
class LookupDict(dict):
"""Dictionary lookup object."""
def __init__(self, name=None):
self.name = name
super(LookupDict, self).__init__()
def __repr__(self):
return '<lookup \'%s\'>' % (self.name)
def __getitem__(self, key):
# We allow fall-through here, so values default to None
return self.__dict__.get(key, None)
def get(self, key, default=None):
return self.__dict__.get(key, default)
api.py 0000644 00000014155 15173103334 0005675 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
"""
from . import sessions
def request(method, url, **kwargs):
"""Constructs and sends a :class:`Request <Request>`.
:param method: method for the new :class:`Request` object.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of 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) A JSON serializable Python object 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 ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds 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) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
: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``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response <Response>` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
<Response [200]>
"""
# By using the 'with' statement we are sure the session is closed, thus we
# avoid leaving sockets open which can trigger a ResourceWarning in some
# cases, and look like a memory leak in others.
with sessions.Session() as session:
return session.request(method=method, url=url, **kwargs)
def get(url, params=None, **kwargs):
r"""Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
kwargs.setdefault('allow_redirects', True)
return request('get', url, params=params, **kwargs)
def options(url, **kwargs):
r"""Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
kwargs.setdefault('allow_redirects', True)
return request('options', url, **kwargs)
def head(url, **kwargs):
r"""Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
kwargs.setdefault('allow_redirects', False)
return request('head', url, **kwargs)
def post(url, data=None, json=None, **kwargs):
r"""Sends a POST request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
return request('post', url, data=data, json=json, **kwargs)
def put(url, data=None, **kwargs):
r"""Sends a PUT request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
return request('put', url, data=data, **kwargs)
def patch(url, data=None, **kwargs):
r"""Sends a PATCH request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
return request('patch', url, data=data, **kwargs)
def delete(url, **kwargs):
r"""Sends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
"""
return request('delete', url, **kwargs)
__pycache__/api.cpython-36.pyc 0000644 00000014414 15173103334 0012157 0 ustar 00 3
��[m � @ s\ d Z ddlmZ dd� Zddd�Zdd � Zd
d � Zdd d
�Zddd�Zddd�Z dd� Z
dS )z�
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
� )�sessionsc K s* t j� �}|jf | |d�|��S Q R X dS )a� Constructs and sends a :class:`Request <Request>`.
:param method: method for the new :class:`Request` object.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of 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) A JSON serializable Python object 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 ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds 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) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
: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``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response <Response>` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
<Response [200]>
)�method�urlN)r ZSession�request)r r �kwargsZsession� r �/usr/lib/python3.6/api.pyr s +
r Nc K s" |j dd� td| fd|i|��S )a[ Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�allow_redirectsT�get�params)�
setdefaultr )r r r r r r r
? s r
c K s |j dd� td| f|�S )z�Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
r T�options)r r )r r r r r r
N s r
c K s |j dd� td| f|�S )z�Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
r F�head)r r )r r r r r r [ s r c K s t d| f||d�|��S )a� Sends a POST request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�post)�data�json)r )r r r r r r r r h s r c K s t d| fd|i|��S )a� Sends a PUT request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�putr )r )r r r r r r r w s r c K s t d| fd|i|��S )a� Sends a PATCH request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�patchr )r )r r r r r r r � s r c K s t d| f|�S )z�Sends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�delete)r )r r r r r r � s r )N)NN)N)N) �__doc__� r r r
r
r r r r r r r r r �<module> s /
__pycache__/hooks.cpython-36.pyc 0000644 00000001605 15173103334 0012527 0 ustar 00 3
��[� � @ s d Z dgZdd� Zdd� ZdS )z�
requests.hooks
~~~~~~~~~~~~~~
This module provides the capabilities for the Requests hooks system.
Available hooks:
``response``:
The response generated from a Request.
Zresponsec C s dd� t D �S )Nc S s i | ]
}g |�qS � r )�.0Zeventr r �/usr/lib/python3.6/hooks.py�
<dictcomp> s z!default_hooks.<locals>.<dictcomp>)�HOOKSr r r r �
default_hooks s r c K sP |pi }|j | �}|rLt|d�r&|g}x$|D ] }||f|�}|dk r,|}q,W |S )z6Dispatches a hook dictionary on a given piece of data.�__call__N)�get�hasattr)�keyZhooksZ hook_data�kwargs�hookZ
_hook_datar r r �
dispatch_hook s
r
N)�__doc__r r r
r r r r �<module>
s __pycache__/packages.cpython-36.pyc 0000644 00000000541 15173103334 0013160 0 ustar 00 3
��[ � @ sf d dl Z xXdD ]PZee�e� e< x<ee j�D ].ZeeksFejed �r,e je e jde < q,W qW dS )� N�urllib3�idna�chardet�.zrequests.packages.)r r r )�sys�package�
__import__�locals�list�modules�mod�
startswith� r r � /usr/lib/python3.6/packages.py�<module> s
__pycache__/adapters.cpython-36.pyc 0000644 00000053725 15173103334 0013221 0 ustar 00 3
|`�h7q � @ sR d Z ddlZddlZddlZddlmZmZ ddlm Z ddl
m Z ddl
m Z
ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddl!m"Z" ddl#m$Z$m%Z% ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3m4Z4m5Z5m Z mZm6Z6m7Z7m8Z8m9Z9 ddl:m;Z; ydd l<m=Z= W n e>k
�r� d d � Z=Y nX d Z?d Z@dZAdZBy ddlCZCe� ZDeDjEe(e'�� W n e>k
�r� dZDY nX d!d"ejFeGejHf eId#�d$d%�ZJd&d!d"d'd(d)�d*d+�ZKG d,d-� d-eL�ZMG d.d/� d/eM�ZNdS )0z�
requests.adapters
~~~~~~~~~~~~~~~~~
This module contains the transport adapters that Requests uses to define
and maintain connections.
� N)� PoolManager�proxy_from_url)� HTTPResponse)� parse_url)�Timeout)�Retry)�create_urllib3_context)�ClosedPoolError)�ConnectTimeoutError)� HTTPError)�
MaxRetryError)�NewConnectionError)�
ProxyError)�
ProtocolError)�ReadTimeoutError)�SSLError)�
ResponseError)�LocationValueError� )�Response)�urlparse�
basestring)�DEFAULT_CA_BUNDLE_PATH�extract_zipped_paths�get_encoding_from_headers�prepend_scheme_if_needed�get_auth_from_url�
urldefragauth� select_proxy)�CaseInsensitiveDict)�extract_cookies_to_jar) �ConnectionError�ConnectTimeout� ReadTimeoutr r �
RetryError�
InvalidSchema�InvalidProxyURL�
InvalidURL)�_basic_auth_str)�SOCKSProxyManagerc O s t d��d S )Nz'Missing dependencies for SOCKS support.)r% )�args�kwargs� r, � /usr/lib/python3.6/adapters.pyr) 0 s r) F�
zbool | str | Nonez#typing.Tuple[str, str] | str | None)�verify� client_cert�poolmanager_kwargs�returnc C s, |j d�}| dko&td k o&| o&|d k}|S )N� ssl_contextT)�get�_preloaded_ssl_context)r/ r0 r1 Zhas_poolmanager_ssl_contextZ should_use_default_ssl_contextr, r, r- �_should_use_default_contextE s
r6 ZPreparedRequestr z<(typing.Dict[str, typing.Any], typing.Dict[str, typing.Any]))�requestr/ r0 � poolmanagerr2 c C s� i }i }t | j�}|jj� }|j}t|di �} d}
d } |dkrDd}
n6t||| �rZt|d< n |dkrltt �} nt
|t �rz|} | d k r�t j
j| �s�| |d< n| |d< |
|d < |d k r�t
|t�r�t|�d
kr�|d |d < |d
|d< n||d < ||j|d�}||fS )NZconnection_pool_kw�
CERT_REQUIREDF� CERT_NONEr3 T�ca_certs� ca_cert_dir� cert_reqs� r � cert_filer �key_file)�scheme�host�port)r �urlrA �lowerrC �getattrr6 r5 r r �
isinstance�str�os�path�isdir�tuple�lenZhostname) r7 r/ r0 r8 � host_params� pool_kwargsZparsed_request_urlrA rC r1 r= �cert_locr, r, r- �_urllib3_request_contextV s<
rQ c s2 e Zd ZdZ� fdd�Zd dd�Zd d
� Z� ZS ) � BaseAdapterzThe Base Transport Adapterc s t t| �j� d S )N)�superrR �__init__)�self)� __class__r, r- rT � s zBaseAdapter.__init__FNTc C s t �dS )aC Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
N)�NotImplementedError)rU r7 �stream�timeoutr/ �cert�proxiesr, r, r- �send� s zBaseAdapter.sendc C s t �dS )z!Cleans up adapter specific items.N)rW )rU r, r, r- �close� s zBaseAdapter.close)FNTNN)�__name__�
__module__� __qualname__�__doc__rT r\ r] �
__classcell__r, r, )rV r- rR � s
rR c s� e Zd ZdZdddddgZeeeef� fdd� Zd d
� Z d d � Z
efd
d�Z dd� Z dd� Z
dd� Zd(dd�Zd)dd�Zd*dd�Zd d � Zd d � Zd d!� Zd"d#� Zd+d&d'�Z� ZS ),� HTTPAdaptera� The built-in HTTP Adapter for urllib3.
Provides a general-case interface for Requests sessions to contact HTTP and
HTTPS urls by implementing the Transport Adapter interface. This class will
usually be created by the :class:`Session <Session>` class under the
covers.
:param pool_connections: The number of urllib3 connection pools to cache.
:param pool_maxsize: The maximum number of connections to save in the pool.
:param max_retries: The maximum number of retries each connection
should attempt. Note, this applies only to failed DNS lookups, socket
connections and connection timeouts, never to requests where data has
made it to the server. By default, Requests does not retry failed
connections. If you need granular control over the conditions under
which we retry a request, import urllib3's ``Retry`` class and pass
that instead.
:param pool_block: Whether the connection pool should block for connections.
Usage::
>>> import requests
>>> s = requests.Session()
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
>>> s.mount('http://', a)
� max_retries�config�_pool_connections�
_pool_maxsize� _pool_blockc sd |t krtddd�| _n tj|�| _i | _i | _tt| �j� || _ || _
|| _ | j |||d� d S )Nr F)�read)�block)
�DEFAULT_RETRIESr rd Zfrom_intre �
proxy_managerrS rc rT rf rg rh �init_poolmanager)rU Zpool_connectionsZ pool_maxsizerd Z
pool_block)rV r, r- rT � s zHTTPAdapter.__init__c s � fdd�� j D �S )Nc s i | ]}t � |d �|�qS )N)rF )�.0�attr)rU r, r- �
<dictcomp>� s z,HTTPAdapter.__getstate__.<locals>.<dictcomp>)� __attrs__)rU r, )rU r- � __getstate__� s zHTTPAdapter.__getstate__c C sH i | _ i | _x |j� D ]\}}t| ||� qW | j| j| j| jd� d S )N)rj )rl re �items�setattrrm rf rg rh )rU �statero �valuer, r, r- � __setstate__� s zHTTPAdapter.__setstate__c K s0 || _ || _|| _tf |||dd�|��| _dS )a Initializes a urllib3 PoolManager.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param connections: The number of urllib3 connection pools to cache.
:param maxsize: The maximum number of connections to save in the pool.
:param block: Block when no free connections are available.
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
T)� num_pools�maxsizerj �strictN)rf rg rh r r8 )rU Z connectionsry rj rO r, r, r- rm � s
z HTTPAdapter.init_poolmanagerc K s� || j kr| j | }n||j� jd�r^t|�\}}t|f||| j| j| jd�|�� }| j |< n4| j|�}t |f|| j| j| jd�|�� }| j |< |S )a� Return urllib3 ProxyManager for the given proxy.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The proxy to return a urllib3 ProxyManager for.
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
:returns: ProxyManager
:rtype: urllib3.ProxyManager
�socks)�username�passwordrx ry rj )�
proxy_headersrx ry rj )
rl rE �
startswithr r) rf rg rh r~ r )rU �proxyZ proxy_kwargsZmanagerr| r} r~ r, r, r- �proxy_manager_for� s*
z HTTPAdapter.proxy_manager_forc C s� |j � jd�rZ|rZd|_|dk rl|}tjj|�s>td|� ���tjj|�sR||_ql||_ nd|_d|_d|_ |r�t
|t �s�|d |_ |d |_
n ||_ d|_
|j r�tjj|j � r�td j|j ���|j
r�tjj|j
� r�td
j|j
���dS ) aA Verify a SSL certificate. This method should not be called from user
code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param conn: The urllib3 connection object associated with the cert.
:param url: The requested URL.
:param verify: 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
:param cert: The SSL certificate to verify.
�httpsr9 TzCCould not find a suitable TLS CA certificate bundle, invalid path: r: Nr r z9Could not find the TLS certificate file, invalid path: {}z1Could not find the TLS key file, invalid path: {})rE r r= rI rJ �exists�OSErrorrK r; r< rG r r? r@ �IOError�format)rU �connrD r/ rZ rP r, r, r- � cert_verify s2
zHTTPAdapter.cert_verifyc C s� t � }t|dd�|_tt|di ��|_t|j�|_||_|jj|_t |j
t �r^|j
j d�|_
n|j
|_
t
|j||� ||_| |_|S )a� Builds a :class:`Response <requests.Response>` object from a urllib3
response. This should not be called from user code, and is only exposed
for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
:param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
:param resp: The urllib3 response object.
:rtype: requests.Response
ZstatusN�headerszutf-8)r rF Z status_coder r� r �encoding�raw�reasonrG rD �bytes�decoder �cookiesr7 �
connection)rU Zreq�respZresponser, r, r- �build_responseL s
zHTTPAdapter.build_responseNc C s t |||| j�S )a� Build the PoolKey attributes used by urllib3 to return a connection.
This looks at the PreparedRequest, the user-specified verify value,
and the value of the cert parameter to determine what PoolKey values
to use to select a connection from a given urllib3 Connection Pool.
The SSL related pool key arguments are not consistently set. As of
this writing, use the following to determine what keys may be in that
dictionary:
* If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the
default Requests SSL Context
* If ``verify`` is ``False``, ``"ssl_context"`` will not be set but
``"cert_reqs"`` will be set
* If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
``"ca_certs"`` will be set if the string is not a directory recognized
by :py:func:`os.path.isdir`, otherwise ``"ca_certs_dir"`` will be
set.
* If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
``"cert"`` is a tuple with a second item, ``"key_file"`` will also
be present
To override these settings, one may subclass this class, call this
method and use the above logic to change parameters as desired. For
example, if one wishes to use a custom :py:class:`ssl.SSLContext` one
must both set ``"ssl_context"`` and based on what else they require,
alter the other keys to ensure the desired behaviour.
:param request:
The PreparedReqest being sent over the connection.
:type request:
:class:`~requests.models.PreparedRequest`
:param verify:
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.
:param cert:
(optional) Any user-provided SSL certificate for client
authentication (a.k.a., mTLS). This may be a string (i.e., just
the path to a file which holds both certificate and key) or a
tuple of length 2 with the certificate file path and key file
path.
:returns:
A tuple of two dictionaries. The first is the "host parameters"
portion of the Pool Key including scheme, hostname, and port. The
second is a dictionary of SSLContext related parameters.
)rQ r8 )rU r7 r/ rZ r, r, r- �$build_connection_pool_key_attributesq s +z0HTTPAdapter.build_connection_pool_key_attributesc C s� t |j|�}y| j|||�\}}W n. tk
rP } zt||d��W Y dd}~X nX |r�t|d�}t|�} | jsvtd��| j |�}
|
j
f |d|i��} n| j j
f |d|i��} | S )ap Returns a urllib3 connection for the given request and TLS settings.
This should not be called from user code, and is only exposed for use
when subclassing the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request:
The :class:`PreparedRequest <PreparedRequest>` object to be sent
over the connection.
:param verify:
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.
:param proxies:
(optional) The proxies dictionary to apply to the request.
:param cert:
(optional) Any user-provided SSL certificate to be used for client
authentication (a.k.a., mTLS).
:rtype:
urllib3.ConnectionPool
)r7 N�httpzFPlease check proxy URL. It is malformed and could be missing the host.rO ) r rD r� �
ValueErrorr' r r rB r& r� Zconnection_from_hostr8 ) rU r7 r/ r[ rZ r� rN rO �e� proxy_urlrl r� r, r, r- � get_connection_with_tls_context� s(
z+HTTPAdapter.get_connection_with_tls_contextc C sd t ||�}|rDt|d�}t|�}|js.td��| j|�}|j|�}n t|�}|j� }| j j|�}|S )a DEPRECATED: Users should move to `get_connection_with_tls_context`
for all subclasses of HTTPAdapter using Requests>=2.32.2.
Returns a urllib3 connection for the given URL. This should not be
called from user code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param url: The URL to connect to.
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
:rtype: urllib3.ConnectionPool
r� zFPlease check proxy URL. It is malformed and could be missing the host.)
r r r rB r& r� Zconnection_from_urlr Zgeturlr8 )rU rD r[ r� r� rl r� Zparsedr, r, r- �get_connection� s
zHTTPAdapter.get_connectionc C s* | j j� x| jj� D ] }|j� qW dS )z�Disposes of any internal state.
Currently, this closes the PoolManager and any active ProxyManager,
which closes any pooled connections.
N)r8 �clearrl �values)rU r� r, r, r- r] � s
zHTTPAdapter.closec C sb t |j|�}t|j�j}|o"|dk}d}|rDt|�jj� }|jd�}|j}|r^| r^t|j�}|S )a? Obtain the url to use when making the final request.
If the message is being sent through a HTTP proxy, the full URL has to
be used. Otherwise, we should only use the path portion of the URL.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
:rtype: str
r� Fr{ )r rD r rA rE r Zpath_urlr ) rU r7 r[ r� rA Zis_proxied_http_requestZusing_socks_proxyZ proxy_schemerD r, r, r- � request_url� s
zHTTPAdapter.request_urlc K s dS )a" Add any headers needed by the connection. As of v2.0 this does
nothing by default, but is left for overriding by users that subclass
the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
:param kwargs: The keyword arguments from the call to send().
Nr, )rU r7 r+ r, r, r- � add_headers s zHTTPAdapter.add_headersc C s& i }t |�\}}|r"t||�|d< |S )a Returns a dictionary of the headers to add to any request sent
through a proxy. This works with urllib3 magic to ensure that they are
correctly sent to the proxy, rather than in a tunnelled request if
CONNECT is being used.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The url of the proxy being used for this request.
:rtype: dict
zProxy-Authorization)r r( )rU r� r� r| r} r, r, r- r~ s
zHTTPAdapter.proxy_headersFTc 7 C s� y| j ||||d�}W n. tk
rD } zt||d��W Y dd}~X nX | j||j||� | j||�} | j||||||d� |jdkp�d|jk }
t |t
�r�y|\} } t | | d�}W n4 t k
r� } zdj
|�}
t |
��W Y dd}~X nX nt |t �r�n t ||d�}�yN|
�s6|j|j| |j|jdddd| j|d �
}�nt|d
��rH|j}|jtd �}y�|j|j| d d
� x$|jj� D ]\}}|j||� �qtW |j� xN|jD ]D}|jtt|��dd� j d�� |jd� |j|� |jd� �q�W |jd� y|j d d�}W n t k
�r |j � }Y nX t j |||ddd�}W n |j!� � Y nX W �n� t"t#j$fk
�r� }
zt%|
|d��W Y dd}
~
X �nZ t&k
�r. } z�t |j't(��r�t |j't)��s�t*||d��t |j't+��r�t,||d��t |j't-��r�t.||d��t |j't/��rt0||d��t%||d��W Y dd}~X n� t1k
�r\ } zt%||d��W Y dd}~X n� t-k
�r� } zt.|��W Y dd}~X n^ t/t2fk
�r� } z<t |t/��r�t0||d��n t |t3��r�t4||d��n� W Y dd}~X nX | j5||�S )a Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 or urllib3 Timeout object
: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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
:rtype: requests.Response
)r[ rZ )r7 N)rX rY r/ rZ r[ zContent-Length)�connectri zrInvalid timeout {}. Pass a (connect, read) timeout tuple, or a single float to set both timeouts to the same valueF)
�methodrD �bodyr� ZredirectZassert_same_host�preload_content�decode_contentZretriesrY �
proxy_pool)rY T)Zskip_accept_encodingr> zutf-8s
s 0
)� buffering)Zpoolr� r� r� )6r� r r' r� rD r� r� r� r� rG rL � TimeoutSaucer� r� Zurlopenr� rd �hasattrr� Z _get_conn�DEFAULT_POOL_TIMEOUTZ
putrequestrs Z putheaderZ
endheadersr\ �hexrM �encodeZ getresponse� TypeErrorr Z from_httplibr] r �socket�errorr! r r� r
r
r" r r$ � _ProxyErrorr � _SSLErrorr r �
_HTTPErrorr r# r� )rU r7 rX rY r/ rZ r[ r� r� rD Zchunkedr� ri �errr� Zlow_conn�headerrv �i�rr, r, r- r\ 5 s�
zHTTPAdapter.send)N)NN)N)FNTNN)r^ r_ r` ra rq �DEFAULT_POOLSIZErk �DEFAULT_POOLBLOCKrT rr rw rm r� r� r� r� r� r� r] r� r� r~ r\ rb r, r, )rV r- rc � s( %3%
-
/
rc )Ora Zos.pathrI r� ZtypingZurllib3.poolmanagerr r Zurllib3.responser Z urllib3.utilr r r� Zurllib3.util.retryr Zurllib3.util.ssl_r Zurllib3.exceptionsr r
r r� r r
r r� r r r r� r r Zmodelsr �compatr r Zutilsr r r r r r r Z
structuresr r� r �
exceptionsr! r" r# r$ r% r& r' Zauthr( Zurllib3.contrib.socksr) � ImportErrorr� r� rk r� Zsslr5 Zload_verify_locationsZDictrH ZAny�boolr6 rQ �objectrR rc r, r, r, r- �<module> sj $ ,
* __pycache__/help.cpython-36.pyc 0000644 00000004765 15173103334 0012346 0 ustar 00 3
��[�
� @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
m Z yddl
mZ W n ek
r� dZdZdZY nX ddlZddlZdd� Zd d
� Zd d � Zed
kr�e� dS )z'Module containing bug report helper(s).� )�print_functionN� )� __version__)� pyopensslc C s� t j� } | dkrt j� }nj| dkr\dtjjtjjtjjf }tjjdkr�dj |tjjg�}n(| dkrnt j� }n| dkr�t j� }nd}| |d �S )
a� Return a dict with the Python implementation and version.
Provide both the name and the version of the Python implementation
currently running. For example, on CPython 2.7.5 it will return
{'name': 'CPython', 'version': '2.7.5'}.
This function works best on CPython and PyPy: in particular, it probably
doesn't work for Jython or IronPython. Future investigation should be done
to work out the correct shape of the code for those platforms.
ZCPythonZPyPyz%s.%s.%s�final� ZJythonZ
IronPython�Unknown)�name�version)
�platformZpython_implementationZpython_version�sysZpypy_version_info�major�minor�micro� releaselevel�join)�implementationZimplementation_version� r �/usr/lib/python3.6/help.py�_implementation s
r c C s� yt j� t j� d�} W n tk
r4 ddd�} Y nX t� }dtji}dtji}ddd�}trrtjdtj j
d�}dt t dd�i}dt t
dd�i}tj
}d|dk r�d| ndi}| ||tdk |||||dtid �
S )
z&Generate information for a bug report.)�system�releaser r
Nr )r
Zopenssl_versionz%xr )
r r �
system_sslZusing_pyopensslZ pyOpenSSL�urllib3�chardet� cryptography�idnaZrequests)r r r �IOErrorr r r r �OpenSSLZSSLZOPENSSL_VERSION_NUMBER�getattrr r �sslr �requests_version) Z
platform_infoZimplementation_infoZ urllib3_infoZ chardet_infoZpyopenssl_infoZcryptography_infoZ idna_infor Zsystem_ssl_infor r r �info; s8
r" c C s t tjt� ddd�� dS )z)Pretty-print the bug information as JSON.T� )Z sort_keys�indentN)�print�json�dumpsr" r r r r �mainq s r( �__main__)�__doc__Z
__future__r r& r r r r r r r r r! Zurllib3.contribr � ImportErrorr r r r" r( �__name__r r r r �<module> s,
!6 __pycache__/api.cpython-36.opt-1.pyc 0000644 00000014414 15173103334 0013116 0 ustar 00 3
��[m � @ s\ d Z ddlmZ dd� Zddd�Zdd � Zd
d � Zdd d
�Zddd�Zddd�Z dd� Z
dS )z�
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
� )�sessionsc K s* t j� �}|jf | |d�|��S Q R X dS )a� Constructs and sends a :class:`Request <Request>`.
:param method: method for the new :class:`Request` object.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of 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) A JSON serializable Python object 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 ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds 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) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
: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``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response <Response>` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
<Response [200]>
)�method�urlN)r ZSession�request)r r �kwargsZsession� r �/usr/lib/python3.6/api.pyr s +
r Nc K s" |j dd� td| fd|i|��S )a[ Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�allow_redirectsT�get�params)�
setdefaultr )r r r r r r r
? s r
c K s |j dd� td| f|�S )z�Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
r T�options)r r )r r r r r r
N s r
c K s |j dd� td| f|�S )z�Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
r F�head)r r )r r r r r r [ s r c K s t d| f||d�|��S )a� Sends a POST request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�post)�data�json)r )r r r r r r r r h s r c K s t d| fd|i|��S )a� Sends a PUT request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�putr )r )r r r r r r r w s r c K s t d| fd|i|��S )a� Sends a PATCH request.
: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 data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�patchr )r )r r r r r r r � s r c K s t d| f|�S )z�Sends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response <Response>` object
:rtype: requests.Response
�delete)r )r r r r r r � s r )N)NN)N)N) �__doc__� r r r
r
r r r r r r r r r �<module> s /
__pycache__/help.cpython-36.opt-1.pyc 0000644 00000004765 15173103334 0013305 0 ustar 00 3
��[�
� @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
m Z yddl
mZ W n ek
r� dZdZdZY nX ddlZddlZdd� Zd d
� Zd d � Zed
kr�e� dS )z'Module containing bug report helper(s).� )�print_functionN� )� __version__)� pyopensslc C s� t j� } | dkrt j� }nj| dkr\dtjjtjjtjjf }tjjdkr�dj |tjjg�}n(| dkrnt j� }n| dkr�t j� }nd}| |d �S )
a� Return a dict with the Python implementation and version.
Provide both the name and the version of the Python implementation
currently running. For example, on CPython 2.7.5 it will return
{'name': 'CPython', 'version': '2.7.5'}.
This function works best on CPython and PyPy: in particular, it probably
doesn't work for Jython or IronPython. Future investigation should be done
to work out the correct shape of the code for those platforms.
ZCPythonZPyPyz%s.%s.%s�final� ZJythonZ
IronPython�Unknown)�name�version)
�platformZpython_implementationZpython_version�sysZpypy_version_info�major�minor�micro� releaselevel�join)�implementationZimplementation_version� r �/usr/lib/python3.6/help.py�_implementation s
r c C s� yt j� t j� d�} W n tk
r4 ddd�} Y nX t� }dtji}dtji}ddd�}trrtjdtj j
d�}dt t dd�i}dt t
dd�i}tj
}d|dk r�d| ndi}| ||tdk |||||dtid �
S )
z&Generate information for a bug report.)�system�releaser r
Nr )r
Zopenssl_versionz%xr )
r r �
system_sslZusing_pyopensslZ pyOpenSSL�urllib3�chardet� cryptography�idnaZrequests)r r r �IOErrorr r r r �OpenSSLZSSLZOPENSSL_VERSION_NUMBER�getattrr r �sslr �requests_version) Z
platform_infoZimplementation_infoZ urllib3_infoZ chardet_infoZpyopenssl_infoZcryptography_infoZ idna_infor Zsystem_ssl_infor r r �info; s8
r" c C s t tjt� ddd�� dS )z)Pretty-print the bug information as JSON.T� )Z sort_keys�indentN)�print�json�dumpsr" r r r r �mainq s r( �__main__)�__doc__Z
__future__r r& r r r r r r r r r! Zurllib3.contribr � ImportErrorr r r r" r( �__name__r r r r �<module> s,
!6 __pycache__/cookies.cpython-36.opt-1.pyc 0000644 00000044424 15173103334 0014005 0 ustar 00 3
��[�G �
@ s� d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z y ddl Z W n e
k
rl ddlZ Y nX G dd� de�ZG dd � d e�Zd
d � Zd d
� Zd dd�ZG dd� de�ZG dd� deje �Zdd� Zdd� Zdd� Zd dd �Z d d � Z dS )!z�
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `cookielib.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
� N� )�to_native_string)� cookielib�urlparse�
urlunparse�Morsel�MutableMappingc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
d dd�Z dd� Z dd� Z
dd� Zedd� �Zedd � �Zed d � �ZdS ) � MockRequesta� Wraps a `requests.Request` to mimic a `urllib2.Request`.
The code in `cookielib.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
c C s || _ i | _t| j j�j| _d S )N)�_r� _new_headersr �url�scheme�type)�self�request� r � /usr/lib/python3.6/cookies.py�__init__% s zMockRequest.__init__c C s | j S )N)r )r r r r �get_type* s zMockRequest.get_typec C s t | jj�jS )N)r r
r Znetloc)r r r r �get_host- s zMockRequest.get_hostc C s | j � S )N)r )r r r r �get_origin_req_host0 s z MockRequest.get_origin_req_hostc C sT | j jjd�s| j jS t| j jd dd�}t| j j�}t|j||j|j |j
|j g�S )NZHostzutf-8)�encoding) r
�headers�getr r r r r
�pathZparamsZqueryZfragment)r �hostZparsedr r r � get_full_url3 s zMockRequest.get_full_urlc C s dS )NTr )r r r r �is_unverifiableA s zMockRequest.is_unverifiablec C s || j jkp|| jkS )N)r
r r )r �namer r r �
has_headerD s zMockRequest.has_headerNc C s | j jj|| jj||��S )N)r
r r r )r r �defaultr r r �
get_headerG s zMockRequest.get_headerc C s t d��dS )zMcookielib has no legitimate use for this method; add it back if you find one.z=Cookie headers should be added with add_unredirected_header()N)�NotImplementedError)r �key�valr r r �
add_headerJ s zMockRequest.add_headerc C s || j |< d S )N)r )r r �valuer r r �add_unredirected_headerN s z#MockRequest.add_unredirected_headerc C s | j S )N)r )r r r r �get_new_headersQ s zMockRequest.get_new_headersc C s | j � S )N)r )r r r r � unverifiableT s zMockRequest.unverifiablec C s | j � S )N)r )r r r r �origin_req_hostX s zMockRequest.origin_req_hostc C s | j � S )N)r )r r r r r \ s zMockRequest.host)N)�__name__�
__module__� __qualname__�__doc__r r r r r r r r! r% r' r( �propertyr) r* r r r r r r s
r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � MockResponsez�Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `cookielib` expects to see them.
c C s
|| _ dS )z�Make a MockResponse for `cookielib` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
N)�_headers)r r r r r r h s zMockResponse.__init__c C s | j S )N)r1 )r r r r �infoo s zMockResponse.infoc C s | j j|� d S )N)r1 �
getheaders)r r r r r r3 r s zMockResponse.getheadersN)r+ r, r- r. r r2 r3 r r r r r0 a s r0 c C s8 t |d�o|jsdS t|�}t|jj�}| j||� dS )z�Extract the cookies from the response into a CookieJar.
:param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
:param request: our own requests.Request object
:param response: urllib3.HTTPResponse object
�_original_responseN)�hasattrr4 r r0 �msgZextract_cookies)�jarr ZresponseZreq�resr r r �extract_cookies_to_jarv s
r9 c C s t |�}| j|� |j� jd�S )zj
Produce an appropriate Cookie header string to be sent with `request`, or None.
:rtype: str
�Cookie)r Zadd_cookie_headerr( r )r7 r �rr r r �get_cookie_header� s
r< c C s� g }xV| D ]N}|j |krq
|dk r.||jkr.q
|dk rB||jkrBq
|j|j|j|j f� q
W x |D ]\}}}| j|||� qbW dS )zkUnsets a cookie by name, by default over all domains and paths.
Wraps CookieJar.clear(), is O(n).
N)r �domainr �append�clear)� cookiejarr r= r Z
clearables�cookier r r �remove_cookie_by_name� s
rB c @ s e Zd ZdZdS )�CookieConflictErrorz�There are two cookies that meet the criteria specified in the cookie jar.
Use .get and .set and include domain and path args in order to be more specific.
N)r+ r, r- r. r r r r rC � s rC c s� e Zd ZdZd3dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd4dd�Z� fdd �Zd d � Zd d � Zd!d"� Z� fd#d$�Z� fd%d&�Zd5d'd(�Zd6d)d*�Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z� Z S )7�RequestsCookieJara� Compatibility class; is a cookielib.CookieJar, but exposes a dict
interface.
This is the CookieJar we create by default for requests and sessions that
don't specify one, since some clients may expect response.cookies and
session.cookies to support dict operations.
Requests does not use the dict interface internally; it's just for
compatibility with external client code. All requests code should work
out of the box with externally provided instances of ``CookieJar``, e.g.
``LWPCookieJar`` and ``FileCookieJar``.
Unlike a regular CookieJar, this class is pickleable.
.. warning:: dictionary operations that are normally O(1) may be O(n).
Nc C s( y| j |||�S tk
r" |S X dS )z�Dict-like get() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
.. warning:: operation is O(n), not O(1).
N)�_find_no_duplicates�KeyError)r r r r= r r r r r � s zRequestsCookieJar.getc K sX |dkr(t | ||jd�|jd�d� dS t|t�r<t|�}nt||f|�}| j|� |S )z�Dict-like set() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
Nr= r )r= r )rB r �
isinstancer �morsel_to_cookie�
create_cookie�
set_cookie)r r r& �kwargs�cr r r �set� s
zRequestsCookieJar.setc c s xt | �D ] }|jV q
W dS )z�Dict-like iterkeys() that returns an iterator of names of cookies
from the jar.
.. seealso:: itervalues() and iteritems().
N)�iterr )r rA r r r �iterkeys� s zRequestsCookieJar.iterkeysc C s t | j� �S )z�Dict-like keys() that returns a list of names of cookies from the
jar.
.. seealso:: values() and items().
)�listrO )r r r r �keys� s zRequestsCookieJar.keysc c s xt | �D ] }|jV q
W dS )z�Dict-like itervalues() that returns an iterator of values of cookies
from the jar.
.. seealso:: iterkeys() and iteritems().
N)rN r& )r rA r r r �
itervalues� s z RequestsCookieJar.itervaluesc C s t | j� �S )z�Dict-like values() that returns a list of values of cookies from the
jar.
.. seealso:: keys() and items().
)rP rR )r r r r �values� s zRequestsCookieJar.valuesc c s$ x t | �D ]}|j|jfV q
W dS )z�Dict-like iteritems() that returns an iterator of name-value tuples
from the jar.
.. seealso:: iterkeys() and itervalues().
N)rN r r& )r rA r r r � iteritems� s zRequestsCookieJar.iteritemsc C s t | j� �S )z�Dict-like items() that returns a list of name-value tuples from the
jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
vanilla python dict of key value pairs.
.. seealso:: keys() and values().
)rP rT )r r r r �items s zRequestsCookieJar.itemsc C s0 g }x&t | �D ]}|j|kr|j|j� qW |S )z2Utility method to list all the domains in the jar.)rN r= r> )r �domainsrA r r r � list_domains s
z RequestsCookieJar.list_domainsc C s0 g }x&t | �D ]}|j|kr|j|j� qW |S )z0Utility method to list all the paths in the jar.)rN r r> )r �pathsrA r r r �
list_paths s
z RequestsCookieJar.list_pathsc C s> g }x4t | �D ](}|jdk r*|j|kr*dS |j|j� qW dS )zvReturns True if there are multiple domains in the jar.
Returns False otherwise.
:rtype: bool
NTF)rN r= r> )r rV rA r r r �multiple_domains s z"RequestsCookieJar.multiple_domainsc C sJ i }x@t | �D ]4}|dks$|j|kr|dks6|j|kr|j||j< qW |S )z�Takes as an argument an optional domain and path and returns a plain
old Python dict of name-value pairs of cookies that meet the
requirements.
:rtype: dict
N)rN r= r r& r )r r= r Z
dictionaryrA r r r �get_dict+ s zRequestsCookieJar.get_dictc s* yt t| �j|�S tk
r$ dS X d S )NT)�superrD � __contains__rC )r r )� __class__r r r] ; s z RequestsCookieJar.__contains__c C s
| j |�S )z�Dict-like __getitem__() for compatibility with client code. Throws
exception if there are more than one cookie with name. In that case,
use the more explicit get() method instead.
.. warning:: operation is O(n), not O(1).
)rE )r r r r r � __getitem__A s z RequestsCookieJar.__getitem__c C s | j ||� dS )z�Dict-like __setitem__ for compatibility with client code. Throws
exception if there is already a cookie of that name in the jar. In that
case, use the more explicit set() method instead.
N)rM )r r r& r r r � __setitem__J s z RequestsCookieJar.__setitem__c C s t | |� dS )zlDeletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
``remove_cookie_by_name()``.
N)rB )r r r r r � __delitem__Q s z RequestsCookieJar.__delitem__c sL t |jd�r4|jjd�r4|jjd�r4|jjdd�|_tt| �j|f|�|�S )N�
startswith�"z\"� )r5 r& rb �endswith�replacer\ rD rJ )r rA �argsrK )r^ r r rJ W s $z RequestsCookieJar.set_cookiec s@ t |tj�r,x.|D ]}| jtj|�� qW ntt| �j|� dS )zAUpdates this jar with cookies from another CookieJar or dict-likeN)rG r � CookieJarrJ �copyr\ rD �update)r �otherrA )r^ r r rj \ s
zRequestsCookieJar.updatec C s\ xDt | �D ]8}|j|kr
|dks*|j|kr
|dks<|j|kr
|jS q
W td|||f ��dS )a� Requests uses this method internally to get cookie values.
If there are conflicting cookies, _find arbitrarily chooses one.
See _find_no_duplicates if you want an exception thrown if there are
conflicting cookies.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:return: cookie.value
Nzname=%r, domain=%r, path=%r)rN r r= r r& rF )r r r= r rA r r r �_findd s
zRequestsCookieJar._findc C s| d}xXt | �D ]L}|j|kr|dks.|j|kr|dks@|j|kr|dk rTtd| ��|j}qW |rf|S td|||f ��dS )a� Both ``__get_item__`` and ``get`` call this function: it's never
used elsewhere in Requests.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:raises KeyError: if cookie is not found
:raises CookieConflictError: if there are multiple cookies
that match name and optionally domain and path
:return: cookie.value
Nz(There are multiple cookies with name, %rzname=%r, domain=%r, path=%r)rN r r= r rC r& rF )r r r= r ZtoReturnrA r r r rE x s
z%RequestsCookieJar._find_no_duplicatesc C s | j j� }|jd� |S )z4Unlike a normal CookieJar, this class is pickleable.�
_cookies_lock)�__dict__ri �pop)r �stater r r � __getstate__� s
z RequestsCookieJar.__getstate__c C s$ | j j|� d| j kr tj� | _dS )z4Unlike a normal CookieJar, this class is pickleable.rm N)rn rj � threading�RLockrm )r rp r r r � __setstate__� s
z RequestsCookieJar.__setstate__c C s" t � }|j| j� � |j| � |S )z(Return a copy of this RequestsCookieJar.)rD Z
set_policy�
get_policyrj )r Znew_cjr r r ri � s
zRequestsCookieJar.copyc C s | j S )z&Return the CookiePolicy instance used.)Z_policy)r r r r ru � s z RequestsCookieJar.get_policy)NNN)NN)NN)NN) r+ r, r- r. r rM rO rQ rR rS rT rU rW rY rZ r[ r] r_ r` ra rJ rj rl rE rq rt ri ru �
__classcell__r r )r^ r rD � s2
rD c C sR | d kr d S t | d�r | j� S tj| �}|j� x | D ]}|jtj|�� q6W |S )Nri )r5 ri r? rJ )r7 Znew_jarrA r r r �_copy_cookie_jar� s
rw c K s� d| |ddddddddddidd�
}t |�t |� }|rLd }t|t|� ��|j|� t|d
�|d < t|d �|d
< |d jd�|d< t|d �|d< tjf |�S )z�Make a cookie from underspecified parameters.
By default, the pair of `name` and `value` will be set for the domain ''
and sent on every request (this is sometimes called a "supercookie").
r Nrd �/FT�HttpOnly)
�versionr r& �portr= r �secure�expires�discard�comment� comment_url�rest�rfc2109z4create_cookie() got unexpected keyword arguments: %sr{ Zport_specifiedr= Zdomain_specified�.Zdomain_initial_dotr Zpath_specified)rM � TypeErrorrP rj �boolrb r r: )r r& rK �resultZbadargs�errr r r rI � s.
rI c C s� d}| d rPy t tj� t | d � �}W qr tk
rL td| d ��Y qrX n"| d rrd}tjtj| d |��}t| d t| d �d| d || j | d dd
| d idt| d �| j
| d
p�dd�
S )zBConvert a Morsel object into a Cookie containing the one k/v pair.Nzmax-agezmax-age: %s must be integerr} z%a, %d-%b-%Y %H:%M:%S GMTr Fr= r ry Zhttponlyr| rz r )
r r� r~ r= r} r r r{ r� r� r| r& rz ) �int�time�
ValueErrorr� �calendarZtimegmZstrptimerI r� r# r& )Zmorselr} Z
time_templater r r rH � s0
rH Tc C sV |dkrt � }| dk rRdd� |D �}x,| D ]$}|s:||kr*|jt|| | �� q*W |S )aC Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
:rtype: CookieJar
Nc S s g | ]
}|j �qS r )r )�.0rA r r r �
<listcomp> s z'cookiejar_from_dict.<locals>.<listcomp>)rD rJ rI )Z cookie_dictr@ � overwriteZnames_from_jarr r r r �cookiejar_from_dict� s
r� c C sz t | tj�std��t |t�r.t|| dd�} nHt |tj�rvy| j|� W n, tk
rt x|D ]}| j|� q^W Y nX | S )z�Add cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
:rtype: CookieJar
z!You can only merge into CookieJarF)r@ r� ) rG r rh r� �dictr� rj �AttributeErrorrJ )r@ ZcookiesZ
cookie_in_jarr r r �
merge_cookies s
r� )NN)NT) r. ri r� r� Z_internal_utilsr �compatr r r r r rr � ImportErrorZdummy_threading�objectr r0 r9 r< rB � RuntimeErrorrC rh rD rw rI rH r� r� r r r r �<module>
s. H
$
__pycache__/hooks.cpython-36.opt-1.pyc 0000644 00000001605 15173103334 0013466 0 ustar 00 3
��[� � @ s d Z dgZdd� Zdd� ZdS )z�
requests.hooks
~~~~~~~~~~~~~~
This module provides the capabilities for the Requests hooks system.
Available hooks:
``response``:
The response generated from a Request.
Zresponsec C s dd� t D �S )Nc S s i | ]
}g |�qS � r )�.0Zeventr r �/usr/lib/python3.6/hooks.py�
<dictcomp> s z!default_hooks.<locals>.<dictcomp>)�HOOKSr r r r �
default_hooks s r c K sP |pi }|j | �}|rLt|d�r&|g}x$|D ] }||f|�}|dk r,|}q,W |S )z6Dispatches a hook dictionary on a given piece of data.�__call__N)�get�hasattr)�keyZhooksZ hook_data�kwargs�hookZ
_hook_datar r r �
dispatch_hook s
r
N)�__doc__r r r
r r r r �<module>
s __pycache__/models.cpython-36.opt-1.pyc 0000644 00000056713 15173103334 0013640 0 ustar 00 3
��[�� � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
mZmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZmZmZ dd
l m Z m Z m Z m Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> ddl2m?Z@ ddlAmBZB eBjCeBjDeBjEeBjFeBjGfZHdZId!ZJdZKG dd� deL�ZMG dd� deL�ZNG dd � d eN�ZOG d d � d eMeN�ZPG d d � d eL�ZQdS )"z`
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
� N)� RequestField)�encode_multipart_formdata)� parse_url)� DecodeError�ReadTimeoutError�
ProtocolError�LocationParseError)�UnsupportedOperation� )�
default_hooks)�CaseInsensitiveDict)�
HTTPBasicAuth)�cookiejar_from_dict�get_cookie_header�_copy_cookie_jar)� HTTPError�
MissingSchema�
InvalidURL�ChunkedEncodingError�ContentDecodingError�ConnectionError�StreamConsumedError)�to_native_string�unicode_is_ascii)
�guess_filename�get_auth_from_url� requote_uri� stream_decode_response_unicode�to_key_val_list�parse_header_links� iter_slices�guess_json_utf� super_len�check_header_validity) �Callable�Mapping� cookielib�
urlunparse�urlsplit� urlencode�str�bytes�is_py2�chardet� builtin_str�
basestring)�json)�codes� �
i i c @ s0 e Zd Zedd� �Zedd� �Zedd� �ZdS )�RequestEncodingMixinc C sN g }t | j�}|j}|s d}|j|� |j}|rD|jd� |j|� dj|�S )zBuild the path URL to use.�/�?� )r( �url�path�append�query�join)�selfr8 �pr9 r; � r? � /usr/lib/python3.6/models.py�path_url= s
z RequestEncodingMixin.path_urlc C s� t | ttf�r| S t| d�r | S t| d�r�g }x|t| �D ]p\}}t |t�sVt|d� r\|g}xJ|D ]B}|dk rb|jt |t�r�|jd�n|t |t�r�|jd�n|f� qbW q8W t|dd�S | S dS )z�Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
�read�__iter__Nzutf-8T)Zdoseq) �
isinstancer* r+ �hasattrr r/ r: �encoder) )�data�result�kZvs�vr? r? r@ �_encode_paramsR s
$ z#RequestEncodingMixin._encode_paramsc C s� | st d��nt|t�r t d��g }t|p,i �}t| p8i �} x�|D ]�\}}t|t�s`t|d� rf|g}x\|D ]T}|dk rlt|t�s�t|�}|jt|t�r�|jd�n|t|t�r�|j d�n|f� qlW qBW x�| D ]�\}}d}d} t|t
t f��r.t |�dk�r|\}
} n&t |�dk�r |\}
} }n |\}
} }} nt
|��p:|}
|} t| tttf��rX| } n(t| d��rn| j� } n| dk�r|q�n| } t|| |
| d �}
|
j|d
� |j|
� q�W t|�\}}||fS ) a� Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
zFiles must be provided.zData must not be a string.rC Nzutf-8� � rB )�namerG �filename�headers)� content_type)�
ValueErrorrD r/ r rE r+ r* r: �decoderF �tuple�list�lenr � bytearrayrB r Zmake_multipartr )�filesrG Z
new_fieldsZfieldsZfield�valrJ rI ZftZfh�fn�fpZfdataZrf�bodyrQ r? r? r@ �
_encode_filesm sP
$
z"RequestEncodingMixin._encode_filesN)�__name__�
__module__� __qualname__�propertyrA � staticmethodrK r] r? r? r? r@ r4 < s r4 c @ s e Zd Zdd� Zdd� ZdS )�RequestHooksMixinc C sZ || j krtd| ��t|t�r2| j | j|� n$t|d�rV| j | jdd� |D �� dS )zProperly register a hook.z1Unsupported event specified, with event name "%s"rC c s s | ]}t |t�r|V qd S )N)rD r$ )�.0�hr? r? r@ � <genexpr>� s z2RequestHooksMixin.register_hook.<locals>.<genexpr>N)�hooksrR rD r$ r: rE �extend)r= �event�hookr? r? r@ �
register_hook� s
z RequestHooksMixin.register_hookc C s. y| j | j|� dS tk
r( dS X dS )ziDeregister a previously registered hook.
Returns True if the hook existed, False if not.
TFN)rg �removerR )r= ri rj r? r? r@ �deregister_hook� s
z!RequestHooksMixin.deregister_hookN)r^ r_ r` rk rm r? r? r? r@ rc � s rc c
@ s* e Zd ZdZd dd�Zdd� Zdd� ZdS )
�Requesta{ A user-created :class:`Request <Request>` object.
Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
<PreparedRequest [GET]>
Nc
C s� |d kr g n|}|d kr g n|}|d kr,i n|}|d kr<i n|}| d krLi n| } t � | _x&t| j� �D ]\} } | j| | d� qfW || _|| _|| _|| _|| _ |
| _
|| _ || _ || _
d S )N)ri rj )r rg rU �itemsrk �methodr8 rP rX rG r0 �params�auth�cookies)
r= rp r8 rP rX rG rq rr rs rg r0 rI rJ r? r? r@ �__init__� s" zRequest.__init__c C s
d| j S )Nz<Request [%s]>)rp )r= r? r? r@ �__repr__� s zRequest.__repr__c C s< t � }|j| j| j| j| j| j| j| j| j | j
| j d�
|S )zXConstructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it.)
rp r8 rP rX rG r0 rq rr rs rg ) �PreparedRequest�preparerp r8 rP rX rG r0 rq rr rs rg )r= r> r? r? r@ rw � s
zRequest.prepare)
NNNNNNNNNN)r^ r_ r` �__doc__rt ru rw r? r? r? r@ rn � s
rn c
@ s� e Zd ZdZdd� Zd dd�Zdd� Zd d
� Zd d � Ze d
d� �Z
dd� Z dd� Z d dd�Z
dd� Zd dd�Zdd� Zd d � ZdS )!rv a� The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
containing the exact bytes that will be sent to the server.
Generated from either a :class:`Request <Request>` object or manually.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
<PreparedRequest [GET]>
>>> s = requests.Session()
>>> s.send(r)
<Response [200]>
c C s0 d | _ d | _d | _d | _d | _t� | _d | _d S )N)rp r8 rP �_cookiesr\ r rg �_body_position)r= r? r? r@ rt " s zPreparedRequest.__init__Nc C sR | j |� | j||� | j|� | j|� | j|||
� | j||� | j| � dS )z6Prepares the entire request with the given parameters.N)�prepare_method� prepare_url�prepare_headers�prepare_cookies� prepare_body� prepare_auth�
prepare_hooks) r= rp r8 rP rX rG rq rr rs rg r0 r? r? r@ rw 3 s
zPreparedRequest.preparec C s
d| j S )Nz<PreparedRequest [%s]>)rp )r= r? r? r@ ru E s zPreparedRequest.__repr__c C sX t � }| j|_| j|_| jd k r*| jj� nd |_t| j�|_| j|_| j|_| j |_ |S )N)
rv rp r8 rP �copyr ry r\ rg rz )r= r> r? r? r@ r� H s zPreparedRequest.copyc C s$ || _ | j dk r t| j j� �| _ dS )z Prepares the given HTTP method.N)rp r �upper)r= rp r? r? r@ r{ S s
z PreparedRequest.prepare_methodc C s@ dd l }y|j| dd�jd�} W n |jk
r: t�Y nX | S )Nr T)Zuts46zutf-8)�idnarF rS Z IDNAError� UnicodeError)�hostr� r? r? r@ �_get_idna_encoded_hostY s
z&PreparedRequest._get_idna_encoded_hostc C s0 t |t�r|jd�}ntr"t|�nt|�}|j� }d|krT|j� jd� rT|| _ dS yt
|�\}}}}}}} W n, t k
r� }
zt |
j
� �W Y dd}
~
X nX |s�d} | jt|d��} t| ��|s�t d| ��t|��sy| j|�}W n tk
�r t d��Y nX n|jd��rt d��|�p"d } | �r2| d
7 } | |7 } |�rP| dt|� 7 } |�sZd }t�r�t |t��rv|jd �}t | t��r�| jd �} t |t��r�|jd �}t |t��r�|jd �}t | t��r�| jd �} t |ttf��r�t|�}| j|�}
|
�r|�r
d
||
f }n|
}tt|| |d|| g��}|| _ dS )z Prepares the given HTTP URL.�utf8�:ZhttpNzDInvalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?z Invalid URL %r: No host suppliedzURL has an invalid label.�*r7 �@r5 zutf-8z%s&%s)rD r+ rS r, Zunicoder* �lstrip�lower�
startswithr8 r r r �args�formatr r r r� r� rF rK r r' )r= r8 rq �schemerr r� Zportr9 r; Zfragment�e�errorZnetlocZ
enc_paramsr? r? r@ r| c sh
zPreparedRequest.prepare_urlc C s@ t � | _|r<x.|j� D ]"}t|� |\}}|| jt|�< qW dS )z Prepares the given HTTP headers.N)r rP ro r# r )r= rP �headerrN �valuer? r? r@ r} � s z PreparedRequest.prepare_headersc C st d}d}| r8|dk r8d}t j|�}t|t�s8|jd�}tt|d�t|ttt t
f� g�}y t |�}W n t t
tfk
r� d}Y nX |r�|}t|dd�dk r�y|j� | _W n ttfk
r� t� | _Y nX |r�td��|r�t|�| jd< n
d| jd < np|�r| j||�\}}n2|�rD| j|�}t|t��s:t|d
��r@d}nd }| j|� |�rjd | jk�rj|| jd
< || _dS )z"Prepares the given HTTP body data.Nzapplication/jsonzutf-8rC �tellz1Streamed bodies and files are mutually exclusive.zContent-LengthZchunkedzTransfer-EncodingrB z!application/x-www-form-urlencodedz content-typez Content-Type) � complexjson�dumpsrD r+ rF �allrE r/ rU rT r% r" � TypeError�AttributeErrorr �getattrr� rz �IOError�OSError�object�NotImplementedErrorr. rP r] rK �prepare_content_lengthr\ )r= rG rX r0 r\ rQ Z is_stream�lengthr? r? r@ r � sJ
z PreparedRequest.prepare_bodyc C sL |dk r$t |�}|rHt|�| jd< n$| jdkrH| jjd�dkrHd| jd< dS )z>Prepare Content-Length header based on request method and bodyNzContent-Length�GET�HEAD�0)r� r� )r" r. rP rp �get)r= r\ r� r? r? r@ r� s z&PreparedRequest.prepare_content_lengthr7 c C sj |dkr"t | j�}t|�r |nd}|rft|t�rDt|�dkrDt|� }|| �}| jj|j� | j | j
� dS )z"Prepares the given HTTP auth data.NrL ) r r8 �anyrD rT rV r
�__dict__�updater� r\ )r= rr r8 Zurl_auth�rr? r? r@ r� s
z PreparedRequest.prepare_authc C s@ t |tj�r|| _n
t|�| _t| j| �}|dk r<|| jd< dS )a Prepares the given HTTP cookie data.
This function eventually generates a ``Cookie`` header from the
given cookies using cookielib. Due to cookielib's design, the header
will not be regenerated if it already exists, meaning this function
can only be called once for the life of the
:class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
NZCookie)rD r& Z CookieJarry r r rP )r= rs Z
cookie_headerr? r? r@ r~ , s
z PreparedRequest.prepare_cookiesc C s* |pg }x |D ]}| j ||| � qW dS )zPrepares the given hooks.N)rk )r= rg ri r? r? r@ r� @ s
z PreparedRequest.prepare_hooks)
NNNNNNNNNN)N)r7 )r^ r_ r` rx rt rw ru r� r{ rb r� r| r} r r� r� r~ r� r? r? r? r@ rv s
V
E
rv c
@ s e Zd ZdZdddddddd d
d g
Zd d
� Zdd� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z d d � Z
ed d � �Zed d!� �Zed"d#� �Zed$d%� �Zed&d'� �Zd;d*d+�Zed,d,fd-d.�Zed/d0� �Zed1d2� �Zd3d4� Zed5d6� �Zd7d8� Zd9d:� Z d,S )<�ResponsezhThe :class:`Response <Response>` object, which contains a
server's response to an HTTP request.
�_content� status_coderP r8 �history�encoding�reasonrs �elapsed�requestc C s^ d| _ d| _d | _d | _t� | _d | _d | _d | _g | _ d | _
t i �| _ t
jd�| _d | _d S )NFr )r� �_content_consumed�_nextr� r rP �rawr8 r� r� r� r rs �datetimeZ timedeltar� r� )r= r? r? r@ rt T s
zResponse.__init__c C s | S )Nr? )r= r? r? r@ � __enter__� s zResponse.__enter__c G s | j � d S )N)�close)r= r� r? r? r@ �__exit__� s zResponse.__exit__c s � j s � j � fdd�� jD �S )Nc s i | ]}t � |d �|�qS )N)r� )rd �attr)r= r? r@ �
<dictcomp>� s z)Response.__getstate__.<locals>.<dictcomp>)r� �content� __attrs__)r= r? )r= r@ � __getstate__� s zResponse.__getstate__c C s> x |j � D ]\}}t| ||� q
W t| dd� t| dd � d S )Nr� Tr� )ro �setattr)r= �staterN r� r? r? r@ � __setstate__� s zResponse.__setstate__c C s
d| j S )Nz<Response [%s]>)r� )r= r? r? r@ ru � s zResponse.__repr__c C s | j S )ak Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
)�ok)r= r? r? r@ �__bool__� s zResponse.__bool__c C s | j S )ak Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
)r� )r= r? r? r@ � __nonzero__� s zResponse.__nonzero__c C s
| j d�S )z,Allows you to use a response as an iterator.� )� iter_content)r= r? r? r@ rC � s zResponse.__iter__c C s& y | j � W n tk
r dS X dS )ax Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
FT)�raise_for_statusr )r= r? r? r@ r� � s
z Response.okc C s d| j ko| jtkS )z�True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
�location)rP r� �REDIRECT_STATI)r= r? r? r@ � is_redirect� s zResponse.is_redirectc C s d| j ko| jtjtjfkS )z@True if this Response one of the permanent versions of redirect.r� )rP r� r1 Zmoved_permanently�permanent_redirect)r= r? r? r@ �is_permanent_redirect� s z Response.is_permanent_redirectc C s | j S )zTReturns a PreparedRequest for the next request in a redirect chain, if there is one.)r� )r= r? r? r@ �next� s z
Response.nextc C s t j| j�d S )z7The apparent encoding, provided by the chardet library.r� )r- Zdetectr� )r= r? r? r@ �apparent_encoding� s zResponse.apparent_encodingr
Fc s~ � �fdd�}�j r(t�jt�r(t� �n$� dk rLt� t� rLtdt� � ��t�j� �}|� }�j rh|n|}|rzt |��}|S )a� Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
c 3 s� t �jd�r�y$x �jj� dd�D ]
} | V q W W q� tk
rZ } zt|��W Y d d }~X q� tk
r� } zt|��W Y d d }~X q� tk
r� } zt|��W Y d d }~X q�X n x �jj � �} | s�P | V q�W d�_
d S )N�streamT)Zdecode_content) rE r� r� r r r r r r rB r� )�chunkr� )�
chunk_sizer= r? r@ �generate� s
z'Response.iter_content.<locals>.generateNz.chunk_size must be an int, it is instead a %s.)
r� rD r� �boolr �intr� �typer r )r= r� �decode_unicoder� Z
reused_chunksZ
stream_chunksZchunksr? )r� r= r@ r� � s
zResponse.iter_contentNc c s� d}x�| j ||d�D ]r}|dk r(|| }|r8|j|�}n|j� }|rn|d rn|rn|d d |d krn|j� }nd}x|D ]
}|V qxW qW |dk r�|V dS )z�Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
N)r� r� r
���r� r� r� )r� �split�
splitlines�pop)r= r� r� Z delimiter�pendingr� �lines�liner? r? r@ �
iter_lines s $
zResponse.iter_linesc C sV | j dkrJ| jrtd��| jdks,| jdkr4d| _ ndj| jt��pFd| _ d| _| j S )z"Content of the response, in bytes.Fz2The content for this response was already consumedr N� T)r� r� � RuntimeErrorr� r� r< r� �CONTENT_CHUNK_SIZE)r= r? r? r@ r� / s
zResponse.contentc C sh d}| j }| jstd�S | j dkr(| j}yt| j|dd�}W n& ttfk
rb t| jdd�}Y nX |S )a� Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
Nr7 �replace)�errors)r� r� r* r� � LookupErrorr� )r= r� r� r? r? r@ �textC s
z
Response.textc K sj | j rZ| jrZt| j�dkrZt| j�}|dk rZytj| jj|�f|�S tk
rX Y nX tj| jf|�S )z�Returns the json-encoded content of a response, if any.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises ValueError: If the response body does not contain valid json.
rM N) r� r� rV r! r� �loadsrS �UnicodeDecodeErrorr� )r= �kwargsr� r? r? r@ r0 i s
z
Response.jsonc C sJ | j jd�}i }|rFt|�}x(|D ] }|jd�p8|jd�}|||< q"W |S )z8Returns the parsed header links of the response, if any.�linkZrelr8 )rP r� r )r= r� �l�linksr� �keyr? r? r@ r� � s
zResponse.linksc C s� d}t | jt�rDy| jjd�}W qJ tk
r@ | jjd�}Y qJX n| j}d| j ko^dk n rxd| j|| jf }n,d| j ko�dk n r�d| j|| jf }|r�t|| d ��d
S ) z2Raises stored :class:`HTTPError`, if one occurred.r7 zutf-8z
iso-8859-1i� i� z %s Client Error: %s for url: %siX z %s Server Error: %s for url: %s)ZresponseN)rD r� r+ rS r� r� r8 r )r= Zhttp_error_msgr� r? r? r@ r� � s zResponse.raise_for_statusc C s0 | j s| jj� t| jdd�}|dk r,|� dS )z�Releases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
� release_connN)r� r� r� r� )r= r� r? r? r@ r� � s
zResponse.close)r
F) r^ r_ r` rx r� rt r� r� r� r� ru r� r� rC ra r� r� r� r� r� r� �ITER_CHUNK_SIZEr� r� r� r0 r� r� r� r? r? r? r@ r� J s2
/
7 & r� i ( )Rrx r� �sysZencodings.idnaZ encodingsZurllib3.fieldsr Zurllib3.filepostr Z urllib3.utilr Zurllib3.exceptionsr r r r �ior rg r Z
structuresr rr r
rs r r r �
exceptionsr r r r r r r Z_internal_utilsr r Zutilsr r r r r r r r! r" r# �compatr$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r� Z status_codesr1 Zmoved�found�otherZtemporary_redirectr� r� ZDEFAULT_REDIRECT_LIMITr� r� r� r4 rc rn rv r� r? r? r? r@ �<module> sB $08 rJ < __pycache__/_internal_utils.cpython-36.opt-1.pyc 0000644 00000002243 15173103334 0015535 0 ustar 00 3
��[H � @ s. d Z ddlmZmZmZ d dd�Zdd� ZdS )
z�
requests._internal_utils
~~~~~~~~~~~~~~
Provides utility functions that are consumed internally by Requests
which depend on extremely few external helpers (such as compat)
� )�is_py2� builtin_str�str�asciic C s. t | t�r| }ntr | j|�}n
| j|�}|S )z�Given a string object, regardless of type, returns a representation of
that string in the native string type, encoding and decoding where
necessary. This assumes ASCII unless told otherwise.
)�
isinstancer r �encode�decode)�string�encoding�out� r �%/usr/lib/python3.6/_internal_utils.py�to_native_string s
r c C s( y| j d� dS tk
r" dS X dS )z�Determine if unicode string only contains ASCII characters.
:param str u_string: unicode string to check. Must be unicode
and not Python 2 `str`.
:rtype: bool
r TFN)r �UnicodeEncodeError)Zu_stringr r r
�unicode_is_ascii s
r N)r )�__doc__�compatr r r r r r r r r
�<module> s
__pycache__/cookies.cpython-36.pyc 0000644 00000044424 15173103334 0013046 0 ustar 00 3
��[�G �
@ s� d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z y ddl Z W n e
k
rl ddlZ Y nX G dd� de�ZG dd � d e�Zd
d � Zd d
� Zd dd�ZG dd� de�ZG dd� deje �Zdd� Zdd� Zdd� Zd dd �Z d d � Z dS )!z�
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `cookielib.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
� N� )�to_native_string)� cookielib�urlparse�
urlunparse�Morsel�MutableMappingc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
d dd�Z dd� Z dd� Z
dd� Zedd� �Zedd � �Zed d � �ZdS ) � MockRequesta� Wraps a `requests.Request` to mimic a `urllib2.Request`.
The code in `cookielib.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
c C s || _ i | _t| j j�j| _d S )N)�_r� _new_headersr �url�scheme�type)�self�request� r � /usr/lib/python3.6/cookies.py�__init__% s zMockRequest.__init__c C s | j S )N)r )r r r r �get_type* s zMockRequest.get_typec C s t | jj�jS )N)r r
r Znetloc)r r r r �get_host- s zMockRequest.get_hostc C s | j � S )N)r )r r r r �get_origin_req_host0 s z MockRequest.get_origin_req_hostc C sT | j jjd�s| j jS t| j jd dd�}t| j j�}t|j||j|j |j
|j g�S )NZHostzutf-8)�encoding) r
�headers�getr r r r r
�pathZparamsZqueryZfragment)r �hostZparsedr r r � get_full_url3 s zMockRequest.get_full_urlc C s dS )NTr )r r r r �is_unverifiableA s zMockRequest.is_unverifiablec C s || j jkp|| jkS )N)r
r r )r �namer r r �
has_headerD s zMockRequest.has_headerNc C s | j jj|| jj||��S )N)r
r r r )r r �defaultr r r �
get_headerG s zMockRequest.get_headerc C s t d��dS )zMcookielib has no legitimate use for this method; add it back if you find one.z=Cookie headers should be added with add_unredirected_header()N)�NotImplementedError)r �key�valr r r �
add_headerJ s zMockRequest.add_headerc C s || j |< d S )N)r )r r �valuer r r �add_unredirected_headerN s z#MockRequest.add_unredirected_headerc C s | j S )N)r )r r r r �get_new_headersQ s zMockRequest.get_new_headersc C s | j � S )N)r )r r r r � unverifiableT s zMockRequest.unverifiablec C s | j � S )N)r )r r r r �origin_req_hostX s zMockRequest.origin_req_hostc C s | j � S )N)r )r r r r r \ s zMockRequest.host)N)�__name__�
__module__� __qualname__�__doc__r r r r r r r r! r% r' r( �propertyr) r* r r r r r r s
r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � MockResponsez�Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `cookielib` expects to see them.
c C s
|| _ dS )z�Make a MockResponse for `cookielib` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
N)�_headers)r r r r r r h s zMockResponse.__init__c C s | j S )N)r1 )r r r r �infoo s zMockResponse.infoc C s | j j|� d S )N)r1 �
getheaders)r r r r r r3 r s zMockResponse.getheadersN)r+ r, r- r. r r2 r3 r r r r r0 a s r0 c C s8 t |d�o|jsdS t|�}t|jj�}| j||� dS )z�Extract the cookies from the response into a CookieJar.
:param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
:param request: our own requests.Request object
:param response: urllib3.HTTPResponse object
�_original_responseN)�hasattrr4 r r0 �msgZextract_cookies)�jarr ZresponseZreq�resr r r �extract_cookies_to_jarv s
r9 c C s t |�}| j|� |j� jd�S )zj
Produce an appropriate Cookie header string to be sent with `request`, or None.
:rtype: str
�Cookie)r Zadd_cookie_headerr( r )r7 r �rr r r �get_cookie_header� s
r< c C s� g }xV| D ]N}|j |krq
|dk r.||jkr.q
|dk rB||jkrBq
|j|j|j|j f� q
W x |D ]\}}}| j|||� qbW dS )zkUnsets a cookie by name, by default over all domains and paths.
Wraps CookieJar.clear(), is O(n).
N)r �domainr �append�clear)� cookiejarr r= r Z
clearables�cookier r r �remove_cookie_by_name� s
rB c @ s e Zd ZdZdS )�CookieConflictErrorz�There are two cookies that meet the criteria specified in the cookie jar.
Use .get and .set and include domain and path args in order to be more specific.
N)r+ r, r- r. r r r r rC � s rC c s� e Zd ZdZd3dd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd4dd�Z� fdd �Zd d � Zd d � Zd!d"� Z� fd#d$�Z� fd%d&�Zd5d'd(�Zd6d)d*�Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z� Z S )7�RequestsCookieJara� Compatibility class; is a cookielib.CookieJar, but exposes a dict
interface.
This is the CookieJar we create by default for requests and sessions that
don't specify one, since some clients may expect response.cookies and
session.cookies to support dict operations.
Requests does not use the dict interface internally; it's just for
compatibility with external client code. All requests code should work
out of the box with externally provided instances of ``CookieJar``, e.g.
``LWPCookieJar`` and ``FileCookieJar``.
Unlike a regular CookieJar, this class is pickleable.
.. warning:: dictionary operations that are normally O(1) may be O(n).
Nc C s( y| j |||�S tk
r" |S X dS )z�Dict-like get() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
.. warning:: operation is O(n), not O(1).
N)�_find_no_duplicates�KeyError)r r r r= r r r r r � s zRequestsCookieJar.getc K sX |dkr(t | ||jd�|jd�d� dS t|t�r<t|�}nt||f|�}| j|� |S )z�Dict-like set() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
Nr= r )r= r )rB r �
isinstancer �morsel_to_cookie�
create_cookie�
set_cookie)r r r& �kwargs�cr r r �set� s
zRequestsCookieJar.setc c s xt | �D ] }|jV q
W dS )z�Dict-like iterkeys() that returns an iterator of names of cookies
from the jar.
.. seealso:: itervalues() and iteritems().
N)�iterr )r rA r r r �iterkeys� s zRequestsCookieJar.iterkeysc C s t | j� �S )z�Dict-like keys() that returns a list of names of cookies from the
jar.
.. seealso:: values() and items().
)�listrO )r r r r �keys� s zRequestsCookieJar.keysc c s xt | �D ] }|jV q
W dS )z�Dict-like itervalues() that returns an iterator of values of cookies
from the jar.
.. seealso:: iterkeys() and iteritems().
N)rN r& )r rA r r r �
itervalues� s z RequestsCookieJar.itervaluesc C s t | j� �S )z�Dict-like values() that returns a list of values of cookies from the
jar.
.. seealso:: keys() and items().
)rP rR )r r r r �values� s zRequestsCookieJar.valuesc c s$ x t | �D ]}|j|jfV q
W dS )z�Dict-like iteritems() that returns an iterator of name-value tuples
from the jar.
.. seealso:: iterkeys() and itervalues().
N)rN r r& )r rA r r r � iteritems� s zRequestsCookieJar.iteritemsc C s t | j� �S )z�Dict-like items() that returns a list of name-value tuples from the
jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
vanilla python dict of key value pairs.
.. seealso:: keys() and values().
)rP rT )r r r r �items s zRequestsCookieJar.itemsc C s0 g }x&t | �D ]}|j|kr|j|j� qW |S )z2Utility method to list all the domains in the jar.)rN r= r> )r �domainsrA r r r � list_domains s
z RequestsCookieJar.list_domainsc C s0 g }x&t | �D ]}|j|kr|j|j� qW |S )z0Utility method to list all the paths in the jar.)rN r r> )r �pathsrA r r r �
list_paths s
z RequestsCookieJar.list_pathsc C s> g }x4t | �D ](}|jdk r*|j|kr*dS |j|j� qW dS )zvReturns True if there are multiple domains in the jar.
Returns False otherwise.
:rtype: bool
NTF)rN r= r> )r rV rA r r r �multiple_domains s z"RequestsCookieJar.multiple_domainsc C sJ i }x@t | �D ]4}|dks$|j|kr|dks6|j|kr|j||j< qW |S )z�Takes as an argument an optional domain and path and returns a plain
old Python dict of name-value pairs of cookies that meet the
requirements.
:rtype: dict
N)rN r= r r& r )r r= r Z
dictionaryrA r r r �get_dict+ s zRequestsCookieJar.get_dictc s* yt t| �j|�S tk
r$ dS X d S )NT)�superrD � __contains__rC )r r )� __class__r r r] ; s z RequestsCookieJar.__contains__c C s
| j |�S )z�Dict-like __getitem__() for compatibility with client code. Throws
exception if there are more than one cookie with name. In that case,
use the more explicit get() method instead.
.. warning:: operation is O(n), not O(1).
)rE )r r r r r � __getitem__A s z RequestsCookieJar.__getitem__c C s | j ||� dS )z�Dict-like __setitem__ for compatibility with client code. Throws
exception if there is already a cookie of that name in the jar. In that
case, use the more explicit set() method instead.
N)rM )r r r& r r r � __setitem__J s z RequestsCookieJar.__setitem__c C s t | |� dS )zlDeletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
``remove_cookie_by_name()``.
N)rB )r r r r r � __delitem__Q s z RequestsCookieJar.__delitem__c sL t |jd�r4|jjd�r4|jjd�r4|jjdd�|_tt| �j|f|�|�S )N�
startswith�"z\"� )r5 r& rb �endswith�replacer\ rD rJ )r rA �argsrK )r^ r r rJ W s $z RequestsCookieJar.set_cookiec s@ t |tj�r,x.|D ]}| jtj|�� qW ntt| �j|� dS )zAUpdates this jar with cookies from another CookieJar or dict-likeN)rG r � CookieJarrJ �copyr\ rD �update)r �otherrA )r^ r r rj \ s
zRequestsCookieJar.updatec C s\ xDt | �D ]8}|j|kr
|dks*|j|kr
|dks<|j|kr
|jS q
W td|||f ��dS )a� Requests uses this method internally to get cookie values.
If there are conflicting cookies, _find arbitrarily chooses one.
See _find_no_duplicates if you want an exception thrown if there are
conflicting cookies.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:return: cookie.value
Nzname=%r, domain=%r, path=%r)rN r r= r r& rF )r r r= r rA r r r �_findd s
zRequestsCookieJar._findc C s| d}xXt | �D ]L}|j|kr|dks.|j|kr|dks@|j|kr|dk rTtd| ��|j}qW |rf|S td|||f ��dS )a� Both ``__get_item__`` and ``get`` call this function: it's never
used elsewhere in Requests.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:raises KeyError: if cookie is not found
:raises CookieConflictError: if there are multiple cookies
that match name and optionally domain and path
:return: cookie.value
Nz(There are multiple cookies with name, %rzname=%r, domain=%r, path=%r)rN r r= r rC r& rF )r r r= r ZtoReturnrA r r r rE x s
z%RequestsCookieJar._find_no_duplicatesc C s | j j� }|jd� |S )z4Unlike a normal CookieJar, this class is pickleable.�
_cookies_lock)�__dict__ri �pop)r �stater r r � __getstate__� s
z RequestsCookieJar.__getstate__c C s$ | j j|� d| j kr tj� | _dS )z4Unlike a normal CookieJar, this class is pickleable.rm N)rn rj � threading�RLockrm )r rp r r r � __setstate__� s
z RequestsCookieJar.__setstate__c C s" t � }|j| j� � |j| � |S )z(Return a copy of this RequestsCookieJar.)rD Z
set_policy�
get_policyrj )r Znew_cjr r r ri � s
zRequestsCookieJar.copyc C s | j S )z&Return the CookiePolicy instance used.)Z_policy)r r r r ru � s z RequestsCookieJar.get_policy)NNN)NN)NN)NN) r+ r, r- r. r rM rO rQ rR rS rT rU rW rY rZ r[ r] r_ r` ra rJ rj rl rE rq rt ri ru �
__classcell__r r )r^ r rD � s2
rD c C sR | d kr d S t | d�r | j� S tj| �}|j� x | D ]}|jtj|�� q6W |S )Nri )r5 ri r? rJ )r7 Znew_jarrA r r r �_copy_cookie_jar� s
rw c K s� d| |ddddddddddidd�
}t |�t |� }|rLd }t|t|� ��|j|� t|d
�|d < t|d �|d
< |d jd�|d< t|d �|d< tjf |�S )z�Make a cookie from underspecified parameters.
By default, the pair of `name` and `value` will be set for the domain ''
and sent on every request (this is sometimes called a "supercookie").
r Nrd �/FT�HttpOnly)
�versionr r& �portr= r �secure�expires�discard�comment� comment_url�rest�rfc2109z4create_cookie() got unexpected keyword arguments: %sr{ Zport_specifiedr= Zdomain_specified�.Zdomain_initial_dotr Zpath_specified)rM � TypeErrorrP rj �boolrb r r: )r r& rK �resultZbadargs�errr r r rI � s.
rI c C s� d}| d rPy t tj� t | d � �}W qr tk
rL td| d ��Y qrX n"| d rrd}tjtj| d |��}t| d t| d �d| d || j | d dd
| d idt| d �| j
| d
p�dd�
S )zBConvert a Morsel object into a Cookie containing the one k/v pair.Nzmax-agezmax-age: %s must be integerr} z%a, %d-%b-%Y %H:%M:%S GMTr Fr= r ry Zhttponlyr| rz r )
r r� r~ r= r} r r r{ r� r� r| r& rz ) �int�time�
ValueErrorr� �calendarZtimegmZstrptimerI r� r# r& )Zmorselr} Z
time_templater r r rH � s0
rH Tc C sV |dkrt � }| dk rRdd� |D �}x,| D ]$}|s:||kr*|jt|| | �� q*W |S )aC Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
:rtype: CookieJar
Nc S s g | ]
}|j �qS r )r )�.0rA r r r �
<listcomp> s z'cookiejar_from_dict.<locals>.<listcomp>)rD rJ rI )Z cookie_dictr@ � overwriteZnames_from_jarr r r r �cookiejar_from_dict� s
r� c C sz t | tj�std��t |t�r.t|| dd�} nHt |tj�rvy| j|� W n, tk
rt x|D ]}| j|� q^W Y nX | S )z�Add cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
:rtype: CookieJar
z!You can only merge into CookieJarF)r@ r� ) rG r rh r� �dictr� rj �AttributeErrorrJ )r@ ZcookiesZ
cookie_in_jarr r r �
merge_cookies s
r� )NN)NT) r. ri r� r� Z_internal_utilsr �compatr r r r r rr � ImportErrorZdummy_threading�objectr r0 r9 r< rB � RuntimeErrorrC rh rD rw rI rH r� r� r r r r �<module>
s. H
$
__pycache__/_internal_utils.cpython-36.pyc 0000644 00000002315 15173103334 0014576 0 ustar 00 3
��[H � @ s. d Z ddlmZmZmZ d dd�Zdd� ZdS )
z�
requests._internal_utils
~~~~~~~~~~~~~~
Provides utility functions that are consumed internally by Requests
which depend on extremely few external helpers (such as compat)
� )�is_py2� builtin_str�str�asciic C s. t | t�r| }ntr | j|�}n
| j|�}|S )z�Given a string object, regardless of type, returns a representation of
that string in the native string type, encoding and decoding where
necessary. This assumes ASCII unless told otherwise.
)�
isinstancer r �encode�decode)�string�encoding�out� r �%/usr/lib/python3.6/_internal_utils.py�to_native_string s
r c C s6 t | t�st�y| jd� dS tk
r0 dS X dS )z�Determine if unicode string only contains ASCII characters.
:param str u_string: unicode string to check. Must be unicode
and not Python 2 `str`.
:rtype: bool
r TFN)r r �AssertionErrorr �UnicodeEncodeError)Zu_stringr r r
�unicode_is_ascii s
r N)r )�__doc__�compatr r r r r r r r r
�<module> s
__pycache__/structures.cpython-36.opt-1.pyc 0000644 00000010314 15173103334 0014563 0 ustar 00 3
��[� � @ s< d Z ddlmZmZmZ G dd� de�ZG dd� de�ZdS )zO
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
� )� OrderedDict�Mapping�MutableMappingc @ sb e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dS )�CaseInsensitiveDicta� A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
Nc K s& t � | _|d kri }| j|f|� d S )N)r �_store�update)�self�data�kwargs� r � /usr/lib/python3.6/structures.py�__init__( s z CaseInsensitiveDict.__init__c C s ||f| j |j� < d S )N)r �lower)r �key�valuer r r � __setitem__. s z CaseInsensitiveDict.__setitem__c C s | j |j� d S )Nr )r r )r r r r r � __getitem__3 s z CaseInsensitiveDict.__getitem__c C s | j |j� = d S )N)r r )r r r r r � __delitem__6 s z CaseInsensitiveDict.__delitem__c C s dd� | j j� D �S )Nc s s | ]\}}|V qd S )Nr )�.0ZcasedkeyZ mappedvaluer r r � <genexpr>: s z/CaseInsensitiveDict.__iter__.<locals>.<genexpr>)r �values)r r r r �__iter__9 s z CaseInsensitiveDict.__iter__c C s
t | j�S )N)�lenr )r r r r �__len__< s zCaseInsensitiveDict.__len__c C s dd� | j j� D �S )z.Like iteritems(), but with all lowercase keys.c s s | ]\}}||d fV qdS )r Nr )r ZlowerkeyZkeyvalr r r r B s z2CaseInsensitiveDict.lower_items.<locals>.<genexpr>)r �items)r r r r � lower_items? s z CaseInsensitiveDict.lower_itemsc C s0 t |t�rt|�}ntS t| j� �t|j� �kS )N)�
isinstancer r �NotImplemented�dictr )r �otherr r r �__eq__G s
zCaseInsensitiveDict.__eq__c C s t | jj� �S )N)r r r )r r r r �copyP s zCaseInsensitiveDict.copyc C s t t| j� ��S )N)�strr r )r r r r �__repr__S s z CaseInsensitiveDict.__repr__)N)�__name__�
__module__� __qualname__�__doc__r
r r r r r r r r! r# r r r r r
s
r c s< e Zd ZdZd � fdd� Zdd� Zdd� Zd d d
�Z� ZS )
�
LookupDictzDictionary lookup object.Nc s || _ tt| �j� d S )N)�name�superr( r
)r r) )� __class__r r r
Z s zLookupDict.__init__c C s
d| j S )Nz
<lookup '%s'>)r) )r r r r r# ^ s zLookupDict.__repr__c C s | j j|d �S )N)�__dict__�get)r r r r r r a s zLookupDict.__getitem__c C s | j j||�S )N)r, r- )r r �defaultr r r r- f s zLookupDict.get)N)N) r$ r% r& r' r
r# r r- �
__classcell__r r )r+ r r( W s
r( N)r' �compatr r r r r r( r r r r �<module> s J __pycache__/status_codes.cpython-36.opt-1.pyc 0000644 00000011133 15173103334 0015040 0 ustar 00 3
��[! � F @ s� d a ddlmZ d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d{�DZed|d}�Zd~d� Ze� d�S )�a�
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
� )�
LookupDict�continue�switching_protocols�
processing�
checkpoint� uri_too_long�request_uri_too_long�ok�okay�all_ok�all_okay�all_good�\o/� ✓�created�accepted�non_authoritative_info� non_authoritative_information�
no_content�
reset_content�reset�partial_content�partial� multi_status�multiple_status� multi_stati�multiple_stati�already_reported�im_used�multiple_choices�moved_permanently�moved�\o-�found� see_other�other� not_modified� use_proxy� switch_proxy�temporary_redirect�temporary_moved� temporary�permanent_redirect�resume_incomplete�resume� bad_request�bad� unauthorized�payment_required�payment� forbidden� not_found�-o-�method_not_allowed� not_allowed�not_acceptable� proxy_authentication_required�
proxy_auth�proxy_authentication�request_timeout�timeout�conflict�gone�length_required�precondition_failed� precondition�request_entity_too_large�request_uri_too_large�unsupported_media_type�unsupported_media�
media_type� requested_range_not_satisfiable�requested_range�range_not_satisfiable�expectation_failed� im_a_teapot�teapot�
i_am_a_teapot�misdirected_request�unprocessable_entity�
unprocessable�locked�failed_dependency�
dependency�unordered_collection� unordered�upgrade_required�upgrade�precondition_required�too_many_requests�too_many�header_fields_too_large�fields_too_large� no_response�none�
retry_with�retry�$blocked_by_windows_parental_controls�parental_controls� unavailable_for_legal_reasons�
legal_reasons�client_closed_request�internal_server_error� server_error�/o\� ✗�not_implemented� bad_gateway�service_unavailable� unavailable�gateway_timeout�http_version_not_supported� http_version�variant_also_negotiates�insufficient_storage�bandwidth_limit_exceeded� bandwidth� not_extended� network_authentication_required� network_auth�network_authentication)D�d �e �f �g �z �� �� �� �� �� �� �� �� �� �� i, i- i. i/ i0 i1 i2 i3 i4 i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� Z status_codes)�namec s� xHt j� D ]<\} }x2|D ]*}tt|| � |jd�stt|j� | � qW q
W dd� � td k r~td dj� fdd�tt �D �� nd ad S ) N�\�/c S s$ dj dd� t| D ��}d| |f S )Nz, c s s | ]}d | V qdS )z``%s``N� )�.0�nr� r� �"/usr/lib/python3.6/status_codes.py� <genexpr>p s z%_init.<locals>.doc.<locals>.<genexpr>z* %d: %s)�join�_codes)�code�namesr� r� r� �doco s z_init.<locals>.doc�
c 3 s | ]}� |�V qd S )Nr� )r� r� )r� r� r� r� u s z_init.<locals>.<genexpr>)r� r� ) r� �items�setattr�codes�
startswith�upper�__doc__r� �sorted)r� Ztitles�titler� )r� r� �_inith s
r� N)r )r )r )r )r r )r r
r r r
r r )r )r )r r )r )r r )r r )r r r r )r )r )r )r r! r" )r# )r$ r% )r& )r' )r( )r) r* r+ )r, r- r. )r/ r0 )r1 )r2 r3 )r4 )r5 r6 )r7 r8 )r9 )r: r; r< )r= r> )r? )r@ )rA )rB rC )rD )rE )rF rG rH )rI rJ rK )rL )rM rN rO )rP )rQ rR )rS )rT rU )rV rW )rX rY )rZ rC )r[ r\ )r] r^ )r_ r` )ra rb )rc rd )re rf )rg )rh ri rj rk )rl )rm )rn ro )rp )rq rr )rs )rt )ru rv )rw )rx ry rz )r� Z
structuresr r� r� r� r� r� r� r� �<module> s�
__pycache__/exceptions.cpython-36.pyc 0000644 00000012450 15173103334 0013565 0 ustar 00 3
��[q � @ s� d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d
� d
e�ZG d d � d e�ZG d
d� de�Z G dd� dee �Z
G dd� de �Z G dd� de�Z G dd� de�Z
G dd� dee�ZG dd� dee�ZG dd � d ee�ZG d d � d ee�ZG d d � d e�ZG d!d"� d"e�ZG d#d$� d$ee�ZG d%d&� d&ee�ZG d'd(� d(e�ZG d)d*� d*e�ZG d+d,� d,e�ZG d-d.� d.ee �Z G d/d0� d0e�Z d1S )2z`
requests.exceptions
~~~~~~~~~~~~~~~~~~~
This module contains the set of Requests' exceptions.
� )� HTTPErrorc s e Zd ZdZ� fdd�Z� ZS )�RequestExceptionzTThere was an ambiguous exception that occurred while handling your
request.
c sZ |j dd�}|| _|j dd�| _|dk rD| j rDt|d�rD| jj| _tt| �j||� dS )zBInitialize RequestException with `request` and `response` objects.�responseN�request)�popr r �hasattr�superr �__init__)�self�args�kwargsr )� __class__� � /usr/lib/python3.6/exceptions.pyr s
zRequestException.__init__)�__name__�
__module__� __qualname__�__doc__r �
__classcell__r r )r
r r s r c @ s e Zd ZdZdS )r zAn HTTP error occurred.N)r r r r r r r r r s r c @ s e Zd ZdZdS )�ConnectionErrorz A Connection error occurred.N)r r r r r r r r r s r c @ s e Zd ZdZdS )�
ProxyErrorzA proxy error occurred.N)r r r r r r r r r $ s r c @ s e Zd ZdZdS )�SSLErrorzAn SSL error occurred.N)r r r r r r r r r ( s r c @ s e Zd ZdZdS )�Timeoutz�The request timed out.
Catching this error will catch both
:exc:`~requests.exceptions.ConnectTimeout` and
:exc:`~requests.exceptions.ReadTimeout` errors.
N)r r r r r r r r r , s r c @ s e Zd ZdZdS )�ConnectTimeoutz�The request timed out while trying to connect to the remote server.
Requests that produced this error are safe to retry.
N)r r r r r r r r r 5 s r c @ s e Zd ZdZdS )� ReadTimeoutz@The server did not send any data in the allotted amount of time.N)r r r r r r r r r < s r c @ s e Zd ZdZdS )� URLRequiredz*A valid URL is required to make a request.N)r r r r r r r r r @ s r c @ s e Zd ZdZdS )�TooManyRedirectszToo many redirects.N)r r r r r r r r r D s r c @ s e Zd ZdZdS )�
MissingSchemaz/The URL schema (e.g. http or https) is missing.N)r r r r r r r r r H s r c @ s e Zd ZdZdS )�
InvalidSchemaz"See defaults.py for valid schemas.N)r r r r r r r r r L s r c @ s e Zd ZdZdS )�
InvalidURLz%The URL provided was somehow invalid.N)r r r r r r r r r P s r c @ s e Zd ZdZdS )�
InvalidHeaderz.The header value provided was somehow invalid.N)r r r r r r r r r T s r c @ s e Zd ZdZdS )�InvalidProxyURLz"The proxy URL provided is invalid.N)r r r r r r r r r! X s r! c @ s e Zd ZdZdS )�ChunkedEncodingErrorz?The server declared chunked encoding but sent an invalid chunk.N)r r r r r r r r r" \ s r" c @ s e Zd ZdZdS )�ContentDecodingErrorz!Failed to decode response contentN)r r r r r r r r r# ` s r# c @ s e Zd ZdZdS )�StreamConsumedErrorz2The content for this response was already consumedN)r r r r r r r r r$ d s r$ c @ s e Zd ZdZdS )�
RetryErrorzCustom retries logic failedN)r r r r r r r r r% h s r% c @ s e Zd ZdZdS )�UnrewindableBodyErrorz:Requests encountered an error when trying to rewind a bodyN)r r r r r r r r r& l s r& c @ s e Zd ZdZdS )�RequestsWarningzBase warning for Requests.N)r r r r r r r r r' r s r' c @ s e Zd ZdZdS )�FileModeWarningzJA file was opened in text mode, but Requests determined its binary length.N)r r r r r r r r r( w s r( c @ s e Zd ZdZdS )�RequestsDependencyWarningz@An imported dependency doesn't match the expected version range.N)r r r r r r r r r) | s r) N) r Zurllib3.exceptionsr Z
BaseHTTPError�IOErrorr r r r r r r r r �
ValueErrorr r r r r! r" r# � TypeErrorr$ r% r& �Warningr' �DeprecationWarningr( r) r r r r �<module> s0 __pycache__/models.cpython-36.pyc 0000644 00000056713 15173103334 0012701 0 ustar 00 3
��[�� � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
mZmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZmZmZ dd
l m Z m Z m Z m Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> ddl2m?Z@ ddlAmBZB eBjCeBjDeBjEeBjFeBjGfZHdZId!ZJdZKG dd� deL�ZMG dd� deL�ZNG dd � d eN�ZOG d d � d eMeN�ZPG d d � d eL�ZQdS )"z`
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
� N)� RequestField)�encode_multipart_formdata)� parse_url)� DecodeError�ReadTimeoutError�
ProtocolError�LocationParseError)�UnsupportedOperation� )�
default_hooks)�CaseInsensitiveDict)�
HTTPBasicAuth)�cookiejar_from_dict�get_cookie_header�_copy_cookie_jar)� HTTPError�
MissingSchema�
InvalidURL�ChunkedEncodingError�ContentDecodingError�ConnectionError�StreamConsumedError)�to_native_string�unicode_is_ascii)
�guess_filename�get_auth_from_url� requote_uri� stream_decode_response_unicode�to_key_val_list�parse_header_links� iter_slices�guess_json_utf� super_len�check_header_validity) �Callable�Mapping� cookielib�
urlunparse�urlsplit� urlencode�str�bytes�is_py2�chardet� builtin_str�
basestring)�json)�codes� �
i i c @ s0 e Zd Zedd� �Zedd� �Zedd� �ZdS )�RequestEncodingMixinc C sN g }t | j�}|j}|s d}|j|� |j}|rD|jd� |j|� dj|�S )zBuild the path URL to use.�/�?� )r( �url�path�append�query�join)�selfr8 �pr9 r; � r? � /usr/lib/python3.6/models.py�path_url= s
z RequestEncodingMixin.path_urlc C s� t | ttf�r| S t| d�r | S t| d�r�g }x|t| �D ]p\}}t |t�sVt|d� r\|g}xJ|D ]B}|dk rb|jt |t�r�|jd�n|t |t�r�|jd�n|f� qbW q8W t|dd�S | S dS )z�Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
�read�__iter__Nzutf-8T)Zdoseq) �
isinstancer* r+ �hasattrr r/ r: �encoder) )�data�result�kZvs�vr? r? r@ �_encode_paramsR s
$ z#RequestEncodingMixin._encode_paramsc C s� | st d��nt|t�r t d��g }t|p,i �}t| p8i �} x�|D ]�\}}t|t�s`t|d� rf|g}x\|D ]T}|dk rlt|t�s�t|�}|jt|t�r�|jd�n|t|t�r�|j d�n|f� qlW qBW x�| D ]�\}}d}d} t|t
t f��r.t |�dk�r|\}
} n&t |�dk�r |\}
} }n |\}
} }} nt
|��p:|}
|} t| tttf��rX| } n(t| d��rn| j� } n| dk�r|q�n| } t|| |
| d �}
|
j|d
� |j|
� q�W t|�\}}||fS ) a� Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
zFiles must be provided.zData must not be a string.rC Nzutf-8� � rB )�namerG �filename�headers)� content_type)�
ValueErrorrD r/ r rE r+ r* r: �decoderF �tuple�list�lenr � bytearrayrB r Zmake_multipartr )�filesrG Z
new_fieldsZfieldsZfield�valrJ rI ZftZfh�fn�fpZfdataZrf�bodyrQ r? r? r@ �
_encode_filesm sP
$
z"RequestEncodingMixin._encode_filesN)�__name__�
__module__� __qualname__�propertyrA � staticmethodrK r] r? r? r? r@ r4 < s r4 c @ s e Zd Zdd� Zdd� ZdS )�RequestHooksMixinc C sZ || j krtd| ��t|t�r2| j | j|� n$t|d�rV| j | jdd� |D �� dS )zProperly register a hook.z1Unsupported event specified, with event name "%s"rC c s s | ]}t |t�r|V qd S )N)rD r$ )�.0�hr? r? r@ � <genexpr>� s z2RequestHooksMixin.register_hook.<locals>.<genexpr>N)�hooksrR rD r$ r: rE �extend)r= �event�hookr? r? r@ �
register_hook� s
z RequestHooksMixin.register_hookc C s. y| j | j|� dS tk
r( dS X dS )ziDeregister a previously registered hook.
Returns True if the hook existed, False if not.
TFN)rg �removerR )r= ri rj r? r? r@ �deregister_hook� s
z!RequestHooksMixin.deregister_hookN)r^ r_ r` rk rm r? r? r? r@ rc � s rc c
@ s* e Zd ZdZd dd�Zdd� Zdd� ZdS )
�Requesta{ A user-created :class:`Request <Request>` object.
Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
<PreparedRequest [GET]>
Nc
C s� |d kr g n|}|d kr g n|}|d kr,i n|}|d kr<i n|}| d krLi n| } t � | _x&t| j� �D ]\} } | j| | d� qfW || _|| _|| _|| _|| _ |
| _
|| _ || _ || _
d S )N)ri rj )r rg rU �itemsrk �methodr8 rP rX rG r0 �params�auth�cookies)
r= rp r8 rP rX rG rq rr rs rg r0 rI rJ r? r? r@ �__init__� s" zRequest.__init__c C s
d| j S )Nz<Request [%s]>)rp )r= r? r? r@ �__repr__� s zRequest.__repr__c C s< t � }|j| j| j| j| j| j| j| j| j | j
| j d�
|S )zXConstructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it.)
rp r8 rP rX rG r0 rq rr rs rg ) �PreparedRequest�preparerp r8 rP rX rG r0 rq rr rs rg )r= r> r? r? r@ rw � s
zRequest.prepare)
NNNNNNNNNN)r^ r_ r` �__doc__rt ru rw r? r? r? r@ rn � s
rn c
@ s� e Zd ZdZdd� Zd dd�Zdd� Zd d
� Zd d � Ze d
d� �Z
dd� Z dd� Z d dd�Z
dd� Zd dd�Zdd� Zd d � ZdS )!rv a� The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
containing the exact bytes that will be sent to the server.
Generated from either a :class:`Request <Request>` object or manually.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
<PreparedRequest [GET]>
>>> s = requests.Session()
>>> s.send(r)
<Response [200]>
c C s0 d | _ d | _d | _d | _d | _t� | _d | _d S )N)rp r8 rP �_cookiesr\ r rg �_body_position)r= r? r? r@ rt " s zPreparedRequest.__init__Nc C sR | j |� | j||� | j|� | j|� | j|||
� | j||� | j| � dS )z6Prepares the entire request with the given parameters.N)�prepare_method� prepare_url�prepare_headers�prepare_cookies� prepare_body� prepare_auth�
prepare_hooks) r= rp r8 rP rX rG rq rr rs rg r0 r? r? r@ rw 3 s
zPreparedRequest.preparec C s
d| j S )Nz<PreparedRequest [%s]>)rp )r= r? r? r@ ru E s zPreparedRequest.__repr__c C sX t � }| j|_| j|_| jd k r*| jj� nd |_t| j�|_| j|_| j|_| j |_ |S )N)
rv rp r8 rP �copyr ry r\ rg rz )r= r> r? r? r@ r� H s zPreparedRequest.copyc C s$ || _ | j dk r t| j j� �| _ dS )z Prepares the given HTTP method.N)rp r �upper)r= rp r? r? r@ r{ S s
z PreparedRequest.prepare_methodc C s@ dd l }y|j| dd�jd�} W n |jk
r: t�Y nX | S )Nr T)Zuts46zutf-8)�idnarF rS Z IDNAError� UnicodeError)�hostr� r? r? r@ �_get_idna_encoded_hostY s
z&PreparedRequest._get_idna_encoded_hostc C s0 t |t�r|jd�}ntr"t|�nt|�}|j� }d|krT|j� jd� rT|| _ dS yt
|�\}}}}}}} W n, t k
r� }
zt |
j
� �W Y dd}
~
X nX |s�d} | jt|d��} t| ��|s�t d| ��t|��sy| j|�}W n tk
�r t d��Y nX n|jd��rt d��|�p"d } | �r2| d
7 } | |7 } |�rP| dt|� 7 } |�sZd }t�r�t |t��rv|jd �}t | t��r�| jd �} t |t��r�|jd �}t |t��r�|jd �}t | t��r�| jd �} t |ttf��r�t|�}| j|�}
|
�r|�r
d
||
f }n|
}tt|| |d|| g��}|| _ dS )z Prepares the given HTTP URL.�utf8�:ZhttpNzDInvalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?z Invalid URL %r: No host suppliedzURL has an invalid label.�*r7 �@r5 zutf-8z%s&%s)rD r+ rS r, Zunicoder* �lstrip�lower�
startswithr8 r r r �args�formatr r r r� r� rF rK r r' )r= r8 rq �schemerr r� Zportr9 r; Zfragment�e�errorZnetlocZ
enc_paramsr? r? r@ r| c sh
zPreparedRequest.prepare_urlc C s@ t � | _|r<x.|j� D ]"}t|� |\}}|| jt|�< qW dS )z Prepares the given HTTP headers.N)r rP ro r# r )r= rP �headerrN �valuer? r? r@ r} � s z PreparedRequest.prepare_headersc C st d}d}| r8|dk r8d}t j|�}t|t�s8|jd�}tt|d�t|ttt t
f� g�}y t |�}W n t t
tfk
r� d}Y nX |r�|}t|dd�dk r�y|j� | _W n ttfk
r� t� | _Y nX |r�td��|r�t|�| jd< n
d| jd < np|�r| j||�\}}n2|�rD| j|�}t|t��s:t|d
��r@d}nd }| j|� |�rjd | jk�rj|| jd
< || _dS )z"Prepares the given HTTP body data.Nzapplication/jsonzutf-8rC �tellz1Streamed bodies and files are mutually exclusive.zContent-LengthZchunkedzTransfer-EncodingrB z!application/x-www-form-urlencodedz content-typez Content-Type) � complexjson�dumpsrD r+ rF �allrE r/ rU rT r% r" � TypeError�AttributeErrorr �getattrr� rz �IOError�OSError�object�NotImplementedErrorr. rP r] rK �prepare_content_lengthr\ )r= rG rX r0 r\ rQ Z is_stream�lengthr? r? r@ r � sJ
z PreparedRequest.prepare_bodyc C sL |dk r$t |�}|rHt|�| jd< n$| jdkrH| jjd�dkrHd| jd< dS )z>Prepare Content-Length header based on request method and bodyNzContent-Length�GET�HEAD�0)r� r� )r" r. rP rp �get)r= r\ r� r? r? r@ r� s z&PreparedRequest.prepare_content_lengthr7 c C sj |dkr"t | j�}t|�r |nd}|rft|t�rDt|�dkrDt|� }|| �}| jj|j� | j | j
� dS )z"Prepares the given HTTP auth data.NrL ) r r8 �anyrD rT rV r
�__dict__�updater� r\ )r= rr r8 Zurl_auth�rr? r? r@ r� s
z PreparedRequest.prepare_authc C s@ t |tj�r|| _n
t|�| _t| j| �}|dk r<|| jd< dS )a Prepares the given HTTP cookie data.
This function eventually generates a ``Cookie`` header from the
given cookies using cookielib. Due to cookielib's design, the header
will not be regenerated if it already exists, meaning this function
can only be called once for the life of the
:class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
NZCookie)rD r& Z CookieJarry r r rP )r= rs Z
cookie_headerr? r? r@ r~ , s
z PreparedRequest.prepare_cookiesc C s* |pg }x |D ]}| j ||| � qW dS )zPrepares the given hooks.N)rk )r= rg ri r? r? r@ r� @ s
z PreparedRequest.prepare_hooks)
NNNNNNNNNN)N)r7 )r^ r_ r` rx rt rw ru r� r{ rb r� r| r} r r� r� r~ r� r? r? r? r@ rv s
V
E
rv c
@ s e Zd ZdZdddddddd d
d g
Zd d
� Zdd� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z d d � Z
ed d � �Zed d!� �Zed"d#� �Zed$d%� �Zed&d'� �Zd;d*d+�Zed,d,fd-d.�Zed/d0� �Zed1d2� �Zd3d4� Zed5d6� �Zd7d8� Zd9d:� Z d,S )<�ResponsezhThe :class:`Response <Response>` object, which contains a
server's response to an HTTP request.
�_content� status_coderP r8 �history�encoding�reasonrs �elapsed�requestc C s^ d| _ d| _d | _d | _t� | _d | _d | _d | _g | _ d | _
t i �| _ t
jd�| _d | _d S )NFr )r� �_content_consumed�_nextr� r rP �rawr8 r� r� r� r rs �datetimeZ timedeltar� r� )r= r? r? r@ rt T s
zResponse.__init__c C s | S )Nr? )r= r? r? r@ � __enter__� s zResponse.__enter__c G s | j � d S )N)�close)r= r� r? r? r@ �__exit__� s zResponse.__exit__c s � j s � j � fdd�� jD �S )Nc s i | ]}t � |d �|�qS )N)r� )rd �attr)r= r? r@ �
<dictcomp>� s z)Response.__getstate__.<locals>.<dictcomp>)r� �content� __attrs__)r= r? )r= r@ � __getstate__� s zResponse.__getstate__c C s> x |j � D ]\}}t| ||� q
W t| dd� t| dd � d S )Nr� Tr� )ro �setattr)r= �staterN r� r? r? r@ � __setstate__� s zResponse.__setstate__c C s
d| j S )Nz<Response [%s]>)r� )r= r? r? r@ ru � s zResponse.__repr__c C s | j S )ak Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
)�ok)r= r? r? r@ �__bool__� s zResponse.__bool__c C s | j S )ak Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
)r� )r= r? r? r@ � __nonzero__� s zResponse.__nonzero__c C s
| j d�S )z,Allows you to use a response as an iterator.� )� iter_content)r= r? r? r@ rC � s zResponse.__iter__c C s& y | j � W n tk
r dS X dS )ax Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
FT)�raise_for_statusr )r= r? r? r@ r� � s
z Response.okc C s d| j ko| jtkS )z�True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
�location)rP r� �REDIRECT_STATI)r= r? r? r@ � is_redirect� s zResponse.is_redirectc C s d| j ko| jtjtjfkS )z@True if this Response one of the permanent versions of redirect.r� )rP r� r1 Zmoved_permanently�permanent_redirect)r= r? r? r@ �is_permanent_redirect� s z Response.is_permanent_redirectc C s | j S )zTReturns a PreparedRequest for the next request in a redirect chain, if there is one.)r� )r= r? r? r@ �next� s z
Response.nextc C s t j| j�d S )z7The apparent encoding, provided by the chardet library.r� )r- Zdetectr� )r= r? r? r@ �apparent_encoding� s zResponse.apparent_encodingr
Fc s~ � �fdd�}�j r(t�jt�r(t� �n$� dk rLt� t� rLtdt� � ��t�j� �}|� }�j rh|n|}|rzt |��}|S )a� Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
c 3 s� t �jd�r�y$x �jj� dd�D ]
} | V q W W q� tk
rZ } zt|��W Y d d }~X q� tk
r� } zt|��W Y d d }~X q� tk
r� } zt|��W Y d d }~X q�X n x �jj � �} | s�P | V q�W d�_
d S )N�streamT)Zdecode_content) rE r� r� r r r r r r rB r� )�chunkr� )�
chunk_sizer= r? r@ �generate� s
z'Response.iter_content.<locals>.generateNz.chunk_size must be an int, it is instead a %s.)
r� rD r� �boolr �intr� �typer r )r= r� �decode_unicoder� Z
reused_chunksZ
stream_chunksZchunksr? )r� r= r@ r� � s
zResponse.iter_contentNc c s� d}x�| j ||d�D ]r}|dk r(|| }|r8|j|�}n|j� }|rn|d rn|rn|d d |d krn|j� }nd}x|D ]
}|V qxW qW |dk r�|V dS )z�Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
N)r� r� r
���r� r� r� )r� �split�
splitlines�pop)r= r� r� Z delimiter�pendingr� �lines�liner? r? r@ �
iter_lines s $
zResponse.iter_linesc C sV | j dkrJ| jrtd��| jdks,| jdkr4d| _ ndj| jt��pFd| _ d| _| j S )z"Content of the response, in bytes.Fz2The content for this response was already consumedr N� T)r� r� � RuntimeErrorr� r� r< r� �CONTENT_CHUNK_SIZE)r= r? r? r@ r� / s
zResponse.contentc C sh d}| j }| jstd�S | j dkr(| j}yt| j|dd�}W n& ttfk
rb t| jdd�}Y nX |S )a� Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
Nr7 �replace)�errors)r� r� r* r� � LookupErrorr� )r= r� r� r? r? r@ �textC s
z
Response.textc K sj | j rZ| jrZt| j�dkrZt| j�}|dk rZytj| jj|�f|�S tk
rX Y nX tj| jf|�S )z�Returns the json-encoded content of a response, if any.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises ValueError: If the response body does not contain valid json.
rM N) r� r� rV r! r� �loadsrS �UnicodeDecodeErrorr� )r= �kwargsr� r? r? r@ r0 i s
z
Response.jsonc C sJ | j jd�}i }|rFt|�}x(|D ] }|jd�p8|jd�}|||< q"W |S )z8Returns the parsed header links of the response, if any.�linkZrelr8 )rP r� r )r= r� �l�linksr� �keyr? r? r@ r� � s
zResponse.linksc C s� d}t | jt�rDy| jjd�}W qJ tk
r@ | jjd�}Y qJX n| j}d| j ko^dk n rxd| j|| jf }n,d| j ko�dk n r�d| j|| jf }|r�t|| d ��d
S ) z2Raises stored :class:`HTTPError`, if one occurred.r7 zutf-8z
iso-8859-1i� i� z %s Client Error: %s for url: %siX z %s Server Error: %s for url: %s)ZresponseN)rD r� r+ rS r� r� r8 r )r= Zhttp_error_msgr� r? r? r@ r� � s zResponse.raise_for_statusc C s0 | j s| jj� t| jdd�}|dk r,|� dS )z�Releases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
� release_connN)r� r� r� r� )r= r� r? r? r@ r� � s
zResponse.close)r
F) r^ r_ r` rx r� rt r� r� r� r� ru r� r� rC ra r� r� r� r� r� r� �ITER_CHUNK_SIZEr� r� r� r0 r� r� r� r? r? r? r@ r� J s2
/
7 & r� i ( )Rrx r� �sysZencodings.idnaZ encodingsZurllib3.fieldsr Zurllib3.filepostr Z urllib3.utilr Zurllib3.exceptionsr r r r �ior rg r Z
structuresr rr r
rs r r r �
exceptionsr r r r r r r Z_internal_utilsr r Zutilsr r r r r r r r! r" r# �compatr$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r� Z status_codesr1 Zmoved�found�otherZtemporary_redirectr� r� ZDEFAULT_REDIRECT_LIMITr� r� r� r4 rc rn rv r� r? r? r? r@ �<module> sB $08 rJ < __pycache__/__version__.cpython-36.opt-1.pyc 0000644 00000000727 15173103335 0014631 0 ustar 00 3
��[� � @ s, d Z dZdZdZdZdZdZdZdZd Z d
S ) ZrequestszPython HTTP for Humans.zhttp://python-requests.orgz2.20.0i z
Kenneth Reitzzme@kennethreitz.orgz
Apache 2.0z Copyright 2018 Kenneth Reitzu ✨ 🍰 ✨N)
Z __title__Z__description__Z__url__� __version__Z __build__�
__author__Z__author_email__Z __license__Z
__copyright__Z__cake__� r r �!/usr/lib/python3.6/__version__.py�<module> s __pycache__/utils.cpython-36.opt-1.pyc 0000644 00000052743 15173103335 0013515 0 ustar 00 3
|`�hGt � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl m Z ddl
mZ ddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$ dd
l%m&Z& dd l'm(Z(m)Z)m*Z*m+Z+ djZ,ej-� Z.ddd�Z/ej0dk�r2dd� Z1dd� Zdd� Z2dd� Z3dkdd �Z4d d � Z5d d � Z6d!d"� Z7d#d$� Z8d%d&� Z9d'd(� Z:dld)d*�Z;d+d,� Z<d-d.� Z=d/d0� Z>d1d2� Z?d3d4� Z@d5d6� ZAd7d8� ZBd9d:� ZCeDdm�ZEd=d>� ZFd?d@� ZGdAdB� ZHdCdD� ZIdEdF� ZJdGdH� ZKejLdIdJ� �ZMdKdL� ZNdndMdN�ZOdOdP� ZPdodRdS�ZQdTdU� ZRdVdW� ZSdXjTdY�ZUeUdZ ZVeUd[ ZWd\d]� ZXd^d_� ZYd`da� ZZej[db�Z\ej[dc�Z]ddde� Z^dfdg� Z_dhdi� Z`dS )pz�
requests.utils
~~~~~~~~~~~~~~
This module provides utility functions that are used within Requests
that are also useful for external consumption.
� N� )� __version__)�certs)�to_native_string)�parse_http_list)�quote�urlparse�bytes�str� OrderedDict�unquote�
getproxies� proxy_bypass�
urlunparse�
basestring�
integer_types�is_py3�proxy_bypass_environment�getproxies_environment�Mapping)�cookiejar_from_dict)�CaseInsensitiveDict)�
InvalidURL�
InvalidHeader�FileModeWarning�UnrewindableBodyError�.netrc�_netrc�P i� )ZhttpZhttpsZwin32c C s� yt rdd l}ndd l}W n tk
r. dS X y6|j|jd�}t|j|d�d �}|j|d�d }W n tk
rz dS X | s�| r�dS |j d�}xX|D ]P}|dkr�d| kr�d S |j
dd
�}|j
d d �}|j
d
d�}t j || t j
�r�d S q�W dS )Nr Fz;Software\Microsoft\Windows\CurrentVersion\Internet SettingsZ ProxyEnableZ
ProxyOverride�;z<local>�.Tz\.�*z.*�?)r �winreg�_winreg� ImportError�OpenKey�HKEY_CURRENT_USER�intZ QueryValueEx�OSError�split�replace�re�match�I)�hostr# ZinternetSettingsZ proxyEnableZ
proxyOverrideZtest� r0 �/usr/lib/python3.6/utils.py�proxy_bypass_registry/ s8
r2 c C s t � rt| �S t| �S dS )z�Return True, if the host should be bypassed.
Checks proxy settings gathered from the environment, if specified,
or the registry.
N)r r r2 )r/ r0 r0 r1 r V s r c C s t | d�r| j� } | S )z/Returns an internal sequence dictionary update.�items)�hasattrr3 )�dr0 r0 r1 �dict_to_sequenceb s
r6 c C s2 d }d}t | d�r t| �}nbt | d�r.| j}nPt | d�r~y | j� }W n tjk
rZ Y n$X tj|�j}d| jkr~t j
dt � t | d��ry | j � }W n$ t
tfk
r� |d k r�|}Y n\X t | d�o�|d k�ry&| jdd � | j � }| j|p�d� W n t
tfk
�r d}Y nX |d k�r$d}td|| �S )
Nr �__len__�len�fileno�ba% Requests has determined the content-length for this request using the binary size of the file: however, the file has been opened in text mode (i.e. without the 'b' flag in the mode). This may lead to an incorrect content-length. In Requests 3.0, support will be removed for files in text mode.�tell�seek� )r4 r8 r9 �io�UnsupportedOperation�os�fstat�st_size�mode�warnings�warnr r; r) �IOErrorr< �max)�oZ total_lengthZcurrent_positionr9 r0 r0 r1 � super_lenk s@
rI Fc C s� y�ddl m }m} d}xJtD ]B}ytjjdj|��}W n tk
rJ dS X tjj|�r |}P q W |dkrndS t | �}|j
}y6||�j |�} | r�| d r�dnd}
| |
| d fS W n |t fk
r� |r̂ Y nX W n t
tfk
r� Y nX dS )z;Returns the Requests tuple auth for a given url from netrc.r )�netrc�NetrcParseErrorNz~/{}r r= )rJ rK � NETRC_FILESr@ �path�
expanduser�format�KeyError�existsr �hostnameZauthenticatorsrF r% �AttributeError) �urlZ raise_errorsrJ rK Z
netrc_path�f�locZrir/ r Zlogin_ir0 r0 r1 �get_netrc_auth� s2
rW c C sB t | dd�}|r>t|t�r>|d dkr>|d dkr>tjj|�S dS )z0Tries to guess the filename of the given object.�nameNr �<r �>���)�getattr�
isinstancer r@ rM �basename)�objrX r0 r0 r1 �guess_filename� s r` c C s� t jj| �r| S t jj| �\}}x4|rTt jj|� rTt jj|�\}}dj||g�}q"W tj|�sd| S tj|�}||j� kr~| S t j
� }t jj|f|jd��� }t jj|�s�|j ||d�}|S )z�Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
�/)rM ) r@ rM rQ r* �join�zipfileZ
is_zipfileZZipFileZnamelist�tempfileZ
gettempdir�extract)rM �archive�member�prefixZzip_fileZtmpZextracted_pathr0 r0 r1 �extract_zipped_paths� s
ri c C s. | dkr dS t | ttttf�r&td��t| �S )a� Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: need more than 1 value to unpack
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
Nz+cannot encode objects that are not 2-tuples)r] r
r �boolr( �
ValueErrorr )�valuer0 r0 r1 �from_key_val_list� s
rm c C s@ | dkr dS t | ttttf�r&td��t | t�r8| j� } t| �S )a� Take an object and test to see if it can be represented as a
dictionary. If it can be, return a list of tuples, e.g.,
::
>>> to_key_val_list([('key', 'val')])
[('key', 'val')]
>>> to_key_val_list({'key': 'val'})
[('key', 'val')]
>>> to_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples.
:rtype: list
Nz+cannot encode objects that are not 2-tuples) r] r
r rj r( rk r r3 �list)rl r0 r0 r1 �to_key_val_list s
ro c C s\ g }xRt | �D ]F}|dd� |dd� ko4dkn rJt|dd� �}|j|� qW |S )a Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
Nr �"r[ r[ )�_parse_list_header�unquote_header_value�append)rl �result�itemr0 r0 r1 �parse_list_header2 s (rv c C s| i }xrt | �D ]f}d|kr$d||< q|jdd�\}} | dd� | dd� koVdkn rlt| dd� �} | ||< qW |S )a^ Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
�=Nr rp r[ r[ )rq r* rr )rl rt ru rX r0 r0 r1 �parse_dict_headerR s ( rx c C s^ | rZ| d | d ko dkn rZ| dd
� } | sF| dd� dkrZ| j dd�j dd�S | S ) z�Unquotes a header value. (Reversal of :func:`quote_header_value`).
This does not use the real unquoting but what browsers are actually
using for quoting.
:param value: the header value to unquote.
:rtype: str
r r rp Nr= z\\�\z\"r[ r[ )r+ )rl Z is_filenamer0 r0 r1 rr u s
$ rr c C s" i }x| D ]}|j ||j< q
W |S )z�Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
)rl rX )�cj� cookie_dictZcookier0 r0 r1 �dict_from_cookiejar� s
r| c C s
t || �S )z�Returns a CookieJar from a key/value dictionary.
:param cj: CookieJar to insert cookies into.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:rtype: CookieJar
)r )rz r{ r0 r0 r1 �add_dict_to_cookiejar� s r} c C sT t jdt� tjdtjd�}tjdtjd�}tjd�}|j| �|j| � |j| � S )zlReturns encodings from given content string.
:param content: bytestring to extract encodings from.
z�In requests 3.0, get_encodings_from_content will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)z!<meta.*?charset=["\']*(.+?)["\'>])�flagsz+<meta.*?content=["\']*;?charset=(.+?)["\'>]z$^<\?xml.*?encoding=["\']*(.+?)["\'>])rD rE �DeprecationWarningr, �compiler. �findall)�contentZ
charset_reZ pragma_reZxml_rer0 r0 r1 �get_encodings_from_content� s
r� c
C s� | j d�}|d j� |dd� }}i }d}xh|D ]`}|j� }|r2|d }}|jd�} | dkr�|d| � j|�}|| d d� j|�}|||j� < q2W ||fS ) z�Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
r r r Nz"' Trw r[ )r* �strip�find�lower)
�header�tokens� content_type�paramsZ params_dictZitems_to_strip�param�keyrl Zindex_of_equalsr0 r0 r1 �_parse_content_type_header� s
r� c C sD | j d�}|sdS t|�\}}d|kr4|d jd�S d|kr@dS dS )z}Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
z content-typeN�charsetz'"�textz
ISO-8859-1)�getr� r� )�headersr� r� r0 r0 r1 �get_encoding_from_headers� s
r� c c sr |j dkr"x| D ]
}|V qW dS tj|j �dd�}x | D ]}|j|�}|r:|V q:W |jddd�}|rn|V dS )zStream decodes a iterator.Nr+ )�errors� T)�final)�encoding�codecs�getincrementaldecoder�decode)�iterator�rru �decoder�chunk�rvr0 r0 r1 � stream_decode_response_unicode� s
r� c c sL d}|dks|dkr t | �}x*|t | �k rF| ||| � V ||7 }q W dS )z Iterate over slices of a string.r N)r8 )�stringZ slice_length�posr0 r0 r1 � iter_slices� s r� c C sv t jdt� g }t| j�}|rJy t| j|�S tk
rH |j|� Y nX yt| j|dd�S t k
rp | jS X dS )z�Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
z�In requests 3.0, get_unicode_from_response will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)r+ )r� N)
rD rE r r� r� r
r� � UnicodeErrorrs � TypeError)r� Ztried_encodingsr� r0 r0 r1 �get_unicode_from_response s
r� Z4ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz0123456789-._~c
C s� | j d�}x�tdt|��D ]�}|| dd� }t|�dkr�|j� r�ytt|d��}W n tk
rt td| ��Y nX |tkr�||| dd� ||< q�d|| ||< qd|| ||< qW dj |�S ) z�Un-escape any percent-escape sequences in a URI that are unreserved
characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
:rtype: str
�%r r r= � z%Invalid percent-escape sequence: '%s'N� )
r* �ranger8 �isalnum�chrr( rk r �UNRESERVED_SETrb )�uri�parts�i�h�cr0 r0 r1 �unquote_unreserved/ s
r� c C s: d}d}yt t| �|d�S tk
r4 t | |d�S X dS )z�Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
z!#$%&'()*+,/:;=?@[]~z!#$&'()*+,/:;=?@[]~)ZsafeN)r r� r )r� Zsafe_with_percentZsafe_without_percentr0 r0 r1 � requote_uriG s r� c C sl t jdtj| ��d }|jd�\}}t jdtjtt|����d }t jdtj|��d |@ }||@ ||@ kS )z�This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
z=Lr ra )�struct�unpack�socket� inet_atonr* �dotted_netmaskr( )ZipZnetZipaddrZnetaddr�bitsZnetmaskZnetworkr0 r0 r1 �address_in_network] s
r� c C s& ddd| > d A }t jtjd|��S )z�Converts mask from /xx format to xxx.xxx.xxx.xxx
Example: if mask is 24 function returns 255.255.255.0
:rtype: str
l �� r � z>I)r� Z inet_ntoar� �pack)�maskr� r0 r0 r1 r� l s r� c C s* yt j| � W n t jk
r$ dS X dS )z
:rtype: bool
FT)r� r� �error)Z string_ipr0 r0 r1 �is_ipv4_addressw s
r� c C s� | j d�dkr�yt| jd�d �}W n tk
r8 dS X |dk sJ|dkrNdS ytj| jd�d � W q� tjk
r| dS X ndS dS )zV
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
ra r Fr� r T)�countr( r* rk r� r� r� )Zstring_networkr� r0 r0 r1 �
is_valid_cidr� s r� c c sT |dk }|r"t jj| �}|t j| < z
dV W d|rN|dkrDt j| = n
|t j| < X dS )z�Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothingN)r@ �environr� )Zenv_namerl Z
value_changedZ old_valuer0 r0 r1 � set_environ� s
r� c C s, dd� }|}|dkr |d�}t | �}|jdkr2dS |r�dd� |jdd �jd
�D �}t|j�r�xz|D ],}t|�r�t|j|�r�dS qb|j|krbdS qbW nD|j}|jr�|d j|j�7 }x&|D ] }|jj |�s�|j |�r�dS q�W t
d|��6 yt |j�}W n t t
jfk
�r d }Y nX W dQ R X |�r(dS d S )
zL
Returns whether we should bypass proxies or not.
:rtype: bool
c S s t jj| �pt jj| j� �S )N)r@ r� r� �upper)�kr0 r0 r1 �<lambda>� s z'should_bypass_proxies.<locals>.<lambda>N�no_proxyTc s s | ]}|r|V qd S )Nr0 )�.0r/ r0 r0 r1 � <genexpr>� s z(should_bypass_proxies.<locals>.<genexpr>� r� �,z:{}F)r rR r+ r* r� r� r� ZportrO �endswithr� r r� r� Zgaierror) rT r� Z get_proxyZ no_proxy_arg�parsedZproxy_ipZhost_with_portr/ Zbypassr0 r0 r1 �should_bypass_proxies� s<
r� c C s t | |d�ri S t� S dS )zA
Return a dict of environment proxies.
:rtype: dict
)r� N)r� r
)rT r� r0 r0 r1 �get_environ_proxies� s r� c C sv |pi }t | �}|jdkr.|j|j|jd��S |jd |j |jd|j dg}d}x |D ]}||krX|| }P qXW |S )z�Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
N�allz://zall://)r rR r� �scheme)rT ZproxiesZurlpartsZ
proxy_keys�proxyZ proxy_keyr0 r0 r1 � select_proxy� s
r� �python-requestsc C s d| t f S )zO
Return a string representing the default user agent.
:rtype: str
z%s/%s)r )rX r0 r0 r1 �default_user_agent s r� c C s t t� djd�ddd��S )z9
:rtype: requests.structures.CaseInsensitiveDict
z, �gzip�deflatez*/*z
keep-alive)z
User-AgentzAccept-EncodingZAcceptZ
Connection)r� r� )r r� rb r0 r0 r0 r1 �default_headers s
r� c C s� g }d}| j |�} | s|S x�tjd| �D ]�}y|jdd�\}}W n tk
r^ |d }}Y nX d|j d�i}xP|jd�D ]B}y|jd�\}} W n tk
r� P Y nX | j |�||j |�< qzW |j|� q(W |S ) z�Return a list of parsed link headers proxies.
i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"
:rtype: list
z '"z, *<r r r� rT z<> '"rw )r� r, r* rk rs ) rl ZlinksZ
replace_chars�valrT r� �linkr� r� r0 r0 r1 �parse_header_links( s&
r� � �asciir= � c C s� | dd� }|t jt jfkr dS |dd� t jkr6dS |dd� t jt jfkrRdS |jt�}|dkrhd S |dkr�|ddd� tkr�d
S |d dd� tkr�d S |dkr�|dd� t kr�d
S |d d� t kr�dS dS )z
:rtype: str
N� zutf-32r� z utf-8-sigr= zutf-16r zutf-8z utf-16-ber z utf-16-lez utf-32-bez utf-32-le)
r� � BOM_UTF32_LE� BOM_UTF32_BE�BOM_UTF8� BOM_UTF16_LE� BOM_UTF16_BEr� �_null�_null2�_null3)�dataZsampleZ nullcountr0 r0 r1 �guess_json_utfS s*
r� c C s8 t | |�\}}}}}}|s$|| }}t||||||f�S )z�Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
)r r )rT Z
new_schemer� �netlocrM r� �query�fragmentr0 r0 r1 �prepend_scheme_if_neededs s
r� c C sB t | �}yt|j�t|j�f}W n ttfk
r< d}Y nX |S )z{Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
r� )r� r� )r r ZusernameZpasswordrS r� )rT r� Zauthr0 r0 r1 �get_auth_from_url� s
r� s ^\S[^\r\n]*$|^$z^\S[^\r\n]*$|^$c C sf | \}}t |t�rt}nt}y|j|�s4td| ��W n* tk
r` td||t|�f ��Y nX dS )z�Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
z7Invalid return character or leading space in header: %sz>Value for header {%s: %s} must be of type str or bytes, not %sN)r] r �_CLEAN_HEADER_REGEX_BYTE�_CLEAN_HEADER_REGEX_STRr- r r� �type)r� rX rl Zpatr0 r0 r1 �check_header_validity� s
r� c C sF t | �\}}}}}}|s"|| }}|jdd�d }t|||||df�S )zW
Given a url remove the fragment and the authentication part.
:rtype: str
�@r r� r[ )r �rsplitr )rT r� r� rM r� r� r� r0 r0 r1 �
urldefragauth� s
r� c C s` t | jdd�}|dk rTt| jt�rTy|| j� W q\ ttfk
rP td��Y q\X ntd��dS )zfMove file pointer back to its recorded starting position
so it can be read again on redirect.
r< Nz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r\ Zbodyr] Z_body_positionr rF r) r )Zprepared_requestZ body_seekr0 r0 r1 � rewind_body� s r� )r r )F)FzBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~)N)r� )a�__doc__r� �
contextlibr> r@ r, r� r� �sysrd rD rc r r� r Z_internal_utilsr �compatr rq r r r r
r r r
r r r r r r r r Zcookiesr Z
structuresr �
exceptionsr r r r rL �whereZDEFAULT_CA_BUNDLE_PATHZ
DEFAULT_PORTS�platformr2 r6 rI rW r` ri rm ro rv rx rr r| r} r� r� r� r� r� r� � frozensetr� r� r� r� r� r� r� �contextmanagerr� r� r� r� r� r� r� �encoder� r� r� r� r� r� r� r� r� r� r� r� r0 r0 r0 r1 �<module> s� D
' =
- #
% =
&
__pycache__/__init__.cpython-36.pyc 0000644 00000006046 15173103335 0013150 0 ustar 00 3
|`�h �
@ s� d Z ddlZddlZddlZddlmZ dd� Zdd� Zyeejej� W n0 e e
fk
rz ej d j ejej�e� Y nX dd
l
mZ ejd e� dd lmZmZmZmZ dd
lmZmZmZmZ ddlmZmZ ddlmZ ddlmZ ddl m Z m Z m Z ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddlm.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 ddl7Z7ddl7m8Z8 e7j9e:�j;e8� � ejde4dd� dS )a�
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings. Basic GET
usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> 'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('https://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key2": "value2",
"key1": "value1"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at <http://python-requests.org>.
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
� N� )�RequestsDependencyWarningc C s� | j d�} | dgkst�t| �dkr.| jd� | \}}}t|�t|�t|� }}}|dks`t�|dkslt�|dksxt�|j d�d d� \}}}t|�t|�t|� }}}|dks�t�|dk s�t�|dks�t�d S ) N�.Zdev� �0r � � � )�split�AssertionError�len�append�int)Zurllib3_versionZchardet_version�major�minor�patch� r � /usr/lib/python3.6/__init__.py�check_compatibility1 s
r c C sV yt tt| jd���} W n tk
r, d S X | dddgk rRdj| �}tj|t� d S )Nr r r � z4Old version of cryptography ({}) may cause slowdown.) �list�mapr r
�
ValueError�format�warnings�warnr )Zcryptography_versionZwarningr r r �_check_cryptographyJ s
r z?urllib3 ({}) or chardet ({}) doesn't match a supported version!)�DependencyWarning�ignore)� __title__�__description__�__url__� __version__)� __build__�
__author__�__author_email__� __license__)�
__copyright__�__cake__)�utils)�packages)�Request�Response�PreparedRequest)�request�get�head�postr �put�delete�options)�session�Session)�codes) �RequestException�Timeout� URLRequired�TooManyRedirects� HTTPError�ConnectionError�FileModeWarning�ConnectTimeout� ReadTimeout)� NullHandler�defaultT)r
)<�__doc__Zurllib3Zchardetr �
exceptionsr r r r" r r r r Zurllib3.exceptionsr � simplefilterr r r! r# r$ r% r& r' r( � r) r* Zmodelsr+ r, r- Zapir. r/ r0 r1 r r2 r3 r4 Zsessionsr5 r6 Z status_codesr7 r8 r9 r: r; r< r= r> r? r@ ZloggingrA Z getLogger�__name__Z
addHandlerr r r r �<module>) s8
( , __pycache__/compat.cpython-36.opt-1.pyc 0000644 00000003050 15173103335 0013623 0 ustar 00 3
��[� � @ s� d Z ddlZddlZejZed dkZed dkZy ddlZW n e k
rZ ddlZY nX e�rddl
m Z m Z m
Z
mZmZmZmZmZmZ ddlmZmZmZmZmZ ddlmZ ddlZddl m Z dd l m Z dd
l m Z m!Z!m"Z"m#Z# e$Z%e$Z&e'Z$e(Z(e)e*e+fZ,e)e*fZ-n�e�r�dd l.mZmZmZmZmZm Z m Z m
Z
mZmZ dd l/mZmZmZmZmZ dd
l0m1Z ddl2m Z dd l3m Z ddl m#Z# ddl4m Z m!Z!m"Z" e$Z%e$Z$e&Z&e$e&fZ(e)e+fZ,e)fZ-dS )zq
requests.compat
~~~~~~~~~~~~~~~
This module handles import compatibility issues between Python 2 and
Python 3.
� N� � ) �quote�unquote�
quote_plus� unquote_plus� urlencode�
getproxies� proxy_bypass�proxy_bypass_environment�getproxies_environment)�urlparse�
urlunparse�urljoin�urlsplit� urldefrag)�parse_http_list)�Morsel)�StringIO)�Callable�Mapping�MutableMapping� OrderedDict)
r
r r r r r r r r r )r r r
r r )� cookiejar)r )r r r )5�__doc__Zchardet�sys� version_infoZ_verZis_py2Zis_py3Z
simplejsonZjson� ImportErrorZurllibr r r r r r r
r r r
r r r r Zurllib2r Z cookielibZCookier r � collectionsr r r r �strZ builtin_str�bytesZunicodeZ
basestring�intZlong�floatZ
numeric_typesZ
integer_typesZ urllib.parseZurllib.requestZhttpr Z http.cookies�io�collections.abc� r% r% � /usr/lib/python3.6/compat.py�<module> sJ ,
0 __pycache__/status_codes.cpython-36.pyc 0000644 00000011133 15173103335 0014102 0 ustar 00 3
��[! � F @ s� d a ddlmZ d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d{�DZed|d}�Zd~d� Ze� d�S )�a�
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
� )�
LookupDict�continue�switching_protocols�
processing�
checkpoint� uri_too_long�request_uri_too_long�ok�okay�all_ok�all_okay�all_good�\o/� ✓�created�accepted�non_authoritative_info� non_authoritative_information�
no_content�
reset_content�reset�partial_content�partial� multi_status�multiple_status� multi_stati�multiple_stati�already_reported�im_used�multiple_choices�moved_permanently�moved�\o-�found� see_other�other� not_modified� use_proxy� switch_proxy�temporary_redirect�temporary_moved� temporary�permanent_redirect�resume_incomplete�resume� bad_request�bad� unauthorized�payment_required�payment� forbidden� not_found�-o-�method_not_allowed� not_allowed�not_acceptable� proxy_authentication_required�
proxy_auth�proxy_authentication�request_timeout�timeout�conflict�gone�length_required�precondition_failed� precondition�request_entity_too_large�request_uri_too_large�unsupported_media_type�unsupported_media�
media_type� requested_range_not_satisfiable�requested_range�range_not_satisfiable�expectation_failed� im_a_teapot�teapot�
i_am_a_teapot�misdirected_request�unprocessable_entity�
unprocessable�locked�failed_dependency�
dependency�unordered_collection� unordered�upgrade_required�upgrade�precondition_required�too_many_requests�too_many�header_fields_too_large�fields_too_large� no_response�none�
retry_with�retry�$blocked_by_windows_parental_controls�parental_controls� unavailable_for_legal_reasons�
legal_reasons�client_closed_request�internal_server_error� server_error�/o\� ✗�not_implemented� bad_gateway�service_unavailable� unavailable�gateway_timeout�http_version_not_supported� http_version�variant_also_negotiates�insufficient_storage�bandwidth_limit_exceeded� bandwidth� not_extended� network_authentication_required� network_auth�network_authentication)D�d �e �f �g �z �� �� �� �� �� �� �� �� �� �� i, i- i. i/ i0 i1 i2 i3 i4 i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� i� Z status_codes)�namec s� xHt j� D ]<\} }x2|D ]*}tt|| � |jd�stt|j� | � qW q
W dd� � td k r~td dj� fdd�tt �D �� nd ad S ) N�\�/c S s$ dj dd� t| D ��}d| |f S )Nz, c s s | ]}d | V qdS )z``%s``N� )�.0�nr� r� �"/usr/lib/python3.6/status_codes.py� <genexpr>p s z%_init.<locals>.doc.<locals>.<genexpr>z* %d: %s)�join�_codes)�code�namesr� r� r� �doco s z_init.<locals>.doc�
c 3 s | ]}� |�V qd S )Nr� )r� r� )r� r� r� r� u s z_init.<locals>.<genexpr>)r� r� ) r� �items�setattr�codes�
startswith�upper�__doc__r� �sorted)r� Ztitles�titler� )r� r� �_inith s
r� N)r )r )r )r )r r )r r
r r r
r r )r )r )r r )r )r r )r r )r r r r )r )r )r )r r! r" )r# )r$ r% )r& )r' )r( )r) r* r+ )r, r- r. )r/ r0 )r1 )r2 r3 )r4 )r5 r6 )r7 r8 )r9 )r: r; r< )r= r> )r? )r@ )rA )rB rC )rD )rE )rF rG rH )rI rJ rK )rL )rM rN rO )rP )rQ rR )rS )rT rU )rV rW )rX rY )rZ rC )r[ r\ )r] r^ )r_ r` )ra rb )rc rd )re rf )rg )rh ri rj rk )rl )rm )rn ro )rp )rq rr )rs )rt )ru rv )rw )rx ry rz )r� Z
structuresr r� r� r� r� r� r� r� �<module> s�
__pycache__/compat.cpython-36.pyc 0000644 00000003050 15173103335 0012664 0 ustar 00 3
��[� � @ s� d Z ddlZddlZejZed dkZed dkZy ddlZW n e k
rZ ddlZY nX e�rddl
m Z m Z m
Z
mZmZmZmZmZmZ ddlmZmZmZmZmZ ddlmZ ddlZddl m Z dd l m Z dd
l m Z m!Z!m"Z"m#Z# e$Z%e$Z&e'Z$e(Z(e)e*e+fZ,e)e*fZ-n�e�r�dd l.mZmZmZmZmZm Z m Z m
Z
mZmZ dd l/mZmZmZmZmZ dd
l0m1Z ddl2m Z dd l3m Z ddl m#Z# ddl4m Z m!Z!m"Z" e$Z%e$Z$e&Z&e$e&fZ(e)e+fZ,e)fZ-dS )zq
requests.compat
~~~~~~~~~~~~~~~
This module handles import compatibility issues between Python 2 and
Python 3.
� N� � ) �quote�unquote�
quote_plus� unquote_plus� urlencode�
getproxies� proxy_bypass�proxy_bypass_environment�getproxies_environment)�urlparse�
urlunparse�urljoin�urlsplit� urldefrag)�parse_http_list)�Morsel)�StringIO)�Callable�Mapping�MutableMapping� OrderedDict)
r
r r r r r r r r r )r r r
r r )� cookiejar)r )r r r )5�__doc__Zchardet�sys� version_infoZ_verZis_py2Zis_py3Z
simplejsonZjson� ImportErrorZurllibr r r r r r r
r r r
r r r r Zurllib2r Z cookielibZCookier r � collectionsr r r r �strZ builtin_str�bytesZunicodeZ
basestring�intZlong�floatZ
numeric_typesZ
integer_typesZ urllib.parseZurllib.requestZhttpr Z http.cookies�io�collections.abc� r% r% � /usr/lib/python3.6/compat.py�<module> sJ ,
0 __pycache__/auth.cpython-36.pyc 0000644 00000020107 15173103335 0012344 0 ustar 00 3
��[�' � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
m Z m Z ddl
mZ ddlmZ ddlmZ d Zd
Zd d � ZG d
d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z]
requests.auth
~~~~~~~~~~~~~
This module contains the authentication handlers for Requests.
� N)� b64encode� )�urlparse�str�
basestring)�extract_cookies_to_jar)�to_native_string)�parse_dict_headerz!application/x-www-form-urlencodedzmultipart/form-datac C s� t | t�s&tjdj| �td� t| �} t |t�sLtjdj|�td� t|�}t | t�r`| jd�} t |t�rt|jd�}dtt dj
| |f��j � � }|S )z Returns a Basic Auth string.z�Non-string usernames will no longer be supported in Requests 3.0.0. Please convert the object you've passed in ({!r}) to a string or bytes object in the near future to avoid problems.)�categoryz�Non-string passwords will no longer be supported in Requests 3.0.0. Please convert the object you've passed in ({!r}) to a string or bytes object in the near future to avoid problems.�latin1zBasic � :) �
isinstancer �warnings�warn�format�DeprecationWarningr �encoder r �join�strip)�username�passwordZauthstr� r �/usr/lib/python3.6/auth.py�_basic_auth_str s&
r c @ s e Zd ZdZdd� ZdS )�AuthBasez4Base class that all auth implementations derive fromc C s t d��d S )Nz Auth hooks must be callable.)�NotImplementedError)�self�rr r r �__call__K s zAuthBase.__call__N)�__name__�
__module__� __qualname__�__doc__r r r r r r H s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �
HTTPBasicAuthz?Attaches HTTP Basic Authentication to the given Request object.c C s || _ || _d S )N)r r )r r r r r r �__init__R s zHTTPBasicAuth.__init__c C s( t | jt|dd �k| jt|dd �kg�S )Nr r )�allr �getattrr )r �otherr r r �__eq__V s zHTTPBasicAuth.__eq__c C s
| |k S )Nr )r r' r r r �__ne__\ s zHTTPBasicAuth.__ne__c C s t | j| j�|jd< |S )N�
Authorization)r r r �headers)r r r r r r _ s zHTTPBasicAuth.__call__N)r r r! r" r$ r( r) r r r r r r# O s
r# c @ s e Zd ZdZdd� ZdS )�
HTTPProxyAuthz=Attaches HTTP Proxy Authentication to a given Request object.c C s t | j| j�|jd< |S )NzProxy-Authorization)r r r r+ )r r r r r r g s zHTTPProxyAuth.__call__N)r r r! r" r r r r r r, d s r, c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dS )�HTTPDigestAuthz@Attaches HTTP Digest Authentication to the given Request object.c C s || _ || _tj� | _d S )N)r r � threadingZlocal�
_thread_local)r r r r r r r$ o s zHTTPDigestAuth.__init__c C s@ t | jd�s<d| j_d| j_d| j_i | j_d | j_d | j_d S )N�initT� r )�hasattrr/ r0 �
last_nonce� nonce_count�chal�pos�
num_401_calls)r r r r �init_per_thread_stateu s z$HTTPDigestAuth.init_per_thread_statec s� | j jd }| j jd }| j jjd�}| j jjd�}| j jjd�}d� |dkrTd}n|j� }|dksl|dkrzd d
� } | � n@|d kr�d d
� }
|
� n*|dkr�dd� } | � n|dkr�dd� } | � � fdd�}
� dkr�dS d}t|�}|jp�d}|jr�|d|j 7 }d| j|| jf }d||f }� |�}� |�}|| j j k�rJ| j j
d7 _
nd| j _
d| j j
}t | j j
�j d �}||j d �7 }|t
j� j d �7 }|tjd �7 }tj|�j� dd � }|dk�rЈ d|||f �}|�s�|
|d||f �}n<|d k�sd |jd �k�r"d!|||d |f }|
||�}ndS || j _ d"| j||||f }|�rT|d#| 7 }|�rf|d$| 7 }|�rx|d%| 7 }|�r�|d&||f 7 }d'| S )(z
:rtype: str
�realm�nonce�qop� algorithm�opaqueNZMD5zMD5-SESSc S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r �hashlibZmd5� hexdigest)�xr r r �md5_utf8� s
z4HTTPDigestAuth.build_digest_header.<locals>.md5_utf8ZSHAc S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> �sha1r? )r@ r r r �sha_utf8� s
z4HTTPDigestAuth.build_digest_header.<locals>.sha_utf8zSHA-256c S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> Zsha256r? )r@ r r r � sha256_utf8� s
z7HTTPDigestAuth.build_digest_header.<locals>.sha256_utf8zSHA-512c S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> Zsha512r? )r@ r r r � sha512_utf8� s
z7HTTPDigestAuth.build_digest_header.<locals>.sha512_utf8c s � d| |f �S )Nz%s:%sr )�s�d)� hash_utf8r r �<lambda>� s z4HTTPDigestAuth.build_digest_header.<locals>.<lambda>�/�?z%s:%s:%sz%s:%sr z%08xzutf-8� � Zauth�,z%s:%s:%s:%s:%sz>username="%s", realm="%s", nonce="%s", uri="%s", response="%s"z
, opaque="%s"z, algorithm="%s"z
, digest="%s"z , qop="auth", nc=%s, cnonce="%s"z Digest %s)r/ r5 �get�upperr �pathZqueryr r r3 r4 r r �timeZctime�os�urandomr> rB r? �split)r �method�urlr9 r: r; r< r= Z
_algorithmrA rC rD rE ZKDZentdigZp_parsedrQ ZA1ZA2ZHA1ZHA2ZncvaluerF ZcnonceZrespdigZnoncebit�baser )rH r �build_digest_header s~
z"HTTPDigestAuth.build_digest_headerc K s |j rd| j_dS )z)Reset num_401_calls counter on redirects.r N)Z is_redirectr/ r7 )r r �kwargsr r r �handle_redirect� s z HTTPDigestAuth.handle_redirectc K s" d|j kodk n s&d| j_|S | jjdk rD|jjj| jj� |jjdd�}d|j � koh| jjdk �r| j jd7 _t
j d t
j d
�}t
|jd|dd ��| j_|j |j� |jj� }t|j|j|j� |j|j� | j|j|j�|jd < |jj|f|�}|j j |� ||_|S d| j_|S )
zo
Takes the given response and tries digest-auth, if needed.
:rtype: requests.Response
i� i� r Nzwww-authenticater1 Zdigest� zdigest )�flags)�countr* ) Z status_coder/ r7 r6 Zrequest�body�seekr+ rO �lower�re�compile�
IGNORECASEr �subr5 Zcontent�close�copyr Z_cookies�rawZprepare_cookiesrY rV rW Z
connection�send�history�append)r r rZ Zs_authZpatZprepZ_rr r r �
handle_401� s.
zHTTPDigestAuth.handle_401c C s~ | j � | jjr&| j|j|j�|jd< y|jj� | j_ W n t
k
rT d | j_ Y nX |j d| j � |j d| j
� d| j_|S )Nr* Zresponser )r8 r/ r3 rY rV rW r+ r_ �tellr6 �AttributeErrorZ
register_hookrl r[ r7 )r r r r r r s zHTTPDigestAuth.__call__c C s( t | jt|dd �k| jt|dd �kg�S )Nr r )r% r r& r )r r' r r r r( * s zHTTPDigestAuth.__eq__c C s
| |k S )Nr )r r' r r r r) 0 s zHTTPDigestAuth.__ne__N) r r r! r" r$ r8 rY r[ rl r r( r) r r r r r- l s
f,r- )r" rS rb rR r> r. r �base64r �compatr r r Zcookiesr Z_internal_utilsr Zutilsr Z CONTENT_TYPE_FORM_URLENCODEDZCONTENT_TYPE_MULTI_PARTr �objectr r# r, r- r r r r �<module> s$ , __pycache__/sessions.cpython-36.opt-1.pyc 0000644 00000045651 15173103335 0014223 0 ustar 00 3
|`�hUs � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z m
Z
m Z m Z m
Z
mZ ddlmZmZmZmZ ddlmZmZmZ dd lmZmZ dd
lm Z dd l m Z m Z m Z dd l!m"Z"m#Z#m$Z$m%Z% dd
l&m'Z' ddl(m)Z) ddl m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1 ddlm2Z2 ej3dk�rNy
ej4Z5W n e6k
�rJ ej7Z5Y nX nejZ5e fdd�Z8e fdd�Z9G dd� de:�Z;G dd� de;�Z<dd � Z=dS ) z�
requests.session
~~~~~~~~~~~~~~~~
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
� N)� timedelta� )�_basic_auth_str)� cookielib�is_py3� OrderedDict�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_STATIZwin32c C st |dkr | S | dkr|S t |t�o*t | t�s0| S |t|��}|jt| �� dd� |j� D �}x|D ]
}||= qbW |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 S s g | ]\}}|d kr|�qS )N� )�.0�k�vr& r& � /usr/lib/python3.6/sessions.py�
<listcomp>I s z!merge_setting.<locals>.<listcomp>)�
isinstancer
r �update�items)Zrequest_settingZsession_setting�
dict_classZmerged_settingZ none_keys�keyr& r& r* �
merge_setting1 s
r1 c C s@ |dks|j d�g kr| S | dks0| j d�g kr4|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)�getr1 )Z
request_hooksZ
session_hooksr/ r& r& r* � merge_hooksP s
r4 c @ s> e Zd Zdd� Zdd� Zddd �Zd
d � Zd d
� Zdd� ZdS )�SessionRedirectMixinc C s, |j r(|jd }tr |jd�}t|d�S dS )z7Receives a Response. Returns a redirect URI or ``None``�location�latin1�utf8N)Z is_redirect�headersr �encoder )�self�respr6 r& r& r* �get_redirect_targeta s
z(SessionRedirectMixin.get_redirect_targetc C s� t |�}t |�}|j|jkr dS |jdkrL|jdkrL|jdkrL|jd krLdS |j|jk}|j|jk}tj|jd�df}| r�|j|kr�|j|kr�dS |p�|S )
zFDecide whether Authorization header should be removed when redirectingTZhttp�P N�https� F)r> N)r@ N)r Zhostname�schemeZportr r3 )r; Zold_urlZnew_urlZ
old_parsedZ
new_parsedZ changed_portZchanged_schemeZ default_portr& r& r* �should_strip_authv s
z&SessionRedirectMixin.should_strip_authFNTc k sd g }
| j |�} t|j�j} �xB| �r^|j� }
|
j|� |
dd� |_y
|j W n( tt t
fk
rv |j j dd� Y nX t
|j�| jkr�td| j |d��|j� | jd�r�t|j�}dt|j�| f } t| �}|jd kr�| r�|j| d
�}n |jr�|j} |j� } |j�st|jt| ��} nt| �} t| �|
_| j|
|� |jtj tj fk�rtd}x |D ]}|
j j |d� �qVW d|
_ |
j }y
|d= W n t!k
�r� Y nX t"|
j#||j � t$|
j#| j%� |
j&|
j#� | j'|
|�}| j(|
|� |
j)dk �o�d |k�p�d
|k}|�r
t*|
� |
}|�r |V q | j+|f|||||dd�| ��}t"| j%|
|j � | j |�} |V q W dS )zBReceives a Response. Returns a generator of Responses or Requests.r NF)Zdecode_contentzExceeded %s redirects.)r2 z//z%s:%s� )�fragment�Content-Length� Content-Type�Transfer-EncodingZCookie)�stream�timeout�verify�cert�proxies�allow_redirects)rE rF rG ),r= r �urlrD �copy�append�history�contentr r � RuntimeError�raw�read�len�
max_redirectsr �close�
startswithr rA �_replaceZgeturlZnetlocr r �rebuild_method� status_coder$ Ztemporary_redirectZpermanent_redirectr9 �popZbody�KeyErrorr Z_cookiesr �cookiesZprepare_cookies�rebuild_proxies� rebuild_authZ_body_positionr# �send)r; r< �reqrH rI rJ rK rL �yield_requestsZadapter_kwargsZhistrN Zprevious_fragment�prepared_requestZ parsed_rurlZparsedZpurged_headers�headerr9 Z
rewindabler& r& r* �resolve_redirects� s|
z&SessionRedirectMixin.resolve_redirectsc C sR |j }|j}d|kr*| j|jj|�r*|d= | jr8t|�nd}|dk rN|j|� 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.
Z
AuthorizationN)r9 rN rB �request� trust_envr Z prepare_auth)r; re r2 r9 rN Znew_authr& r& r* ra s
z!SessionRedirectMixin.rebuild_authc
C s� |dk r |ni }|j }|j}t|�j}|j� }|jd�}t||d�}| jr~| r~t||d�} | j|| jd��}
|
r~|j ||
� d|kr�|d= yt
|| �\} } W n t k
r� d\} } Y nX |j d� r�| r�| r�t
| | �|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)rj �allzProxy-Authorizationr? )NN)r9 rN r rA rO r3 r! ri r �
setdefaultr" r^ rY r )
r; re rL r9 rN rA Z new_proxiesrj Z bypass_proxyZenviron_proxies�proxyZusernameZpasswordr& r& r* r` s*
z$SessionRedirectMixin.rebuild_proxiesc C sX |j }|jtjkr |dkr d}|jtjkr6|dkr6d}|jtjkrN|dkrNd}||_ 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$ Z see_other�foundZmoved)r; re r2 rq r& r& r* r[ ? s z#SessionRedirectMixin.rebuild_method)FNTNNF) �__name__�
__module__� __qualname__r= rB rg ra r` r[ r& r& r& r* r5 _ s
p+r5 c @ s� e Zd ZdZdddddddd d
d d d
dg
Zdd� Zdd� Zdd� Zdd� Zd7dd�Z dd � Z
d d � Z d d � Z d8d!d"�Z
d9d#d$�Zd:d%d&�Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� 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]>
r9 r_ �authrL �hooks�paramsrJ rK Zprefetch�adaptersrH ri rW c C sr t � | _d | _i | _t� | _i | _d| _d| _d | _ t
| _ d| _ t
i �| _t� | _| jdt� � | jdt� � d S )NFTzhttps://zhttp://)r r9 rw rL r rx ry rH rJ rK r rW ri r r_ r rz �mountr )r; r& r& r* �__init__o s
zSession.__init__c C s | S )Nr& )r; r& r& r* � __enter__� s zSession.__enter__c G s | j � d S )N)rX )r; �argsr& r& r* �__exit__� s zSession.__exit__c
C s� |j pi }t|tj�s t|�}ttt� | j �|�}|j}| jrV| rV| j rVt |j
�}t � }|j |j
j� |j
|j|j|jt|j| jtd�t|j| j�t|| j�|t|j| j�d�
|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
)r/ )
rq rN �files�data�jsonr9 ry rw r_ rx )r_ r, r Z CookieJarr r r
rw ri r rN r Zpreparerq �upperr� r� r� r1 r9 r ry r4 rx )r; rh r_ Zmerged_cookiesrw �pr& r& r* �prepare_request� s*
zSession.prepare_requestNTc C st t |j� ||||pi ||p i ||| d�
}| j|�}| p8i } | j|j| |
||�}| |
d�}|j|� | j|f|�}|S )a 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``.
:param cert: (optional) if String, path to ssl client cert file (.pem).
If Tuple, ('cert', 'key') pair.
:rtype: requests.Response
)
rq rN r9 r� r� r� ry rw r_ rx )rI rM )r r� r� �merge_environment_settingsrN r- rb )r; rq rN ry r� r9 r_ r� rw rI rM rL rx rH rJ rK r� rc ZprepZsettingsZ send_kwargsr< r& r& r* rh � s( )
zSession.requestc K s |j dd� | jd|f|�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
rM Tro )rl rh )r; rN �kwargsr& r& r* r3 s z Session.getc K s |j dd� | jd|f|�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
rM TZOPTIONS)rl rh )r; rN r� r& r& r* �options& s zSession.optionsc K s |j dd� | jd|f|�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
rM Frn )rl rh )r; rN r� r& r& r* �head1 s z Session.headc K s | 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
rp )r� r� )rh )r; rN r� r� r� r& r& r* �post< s z Session.postc K s | 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
ZPUTr� )rh )r; rN r� r� r& r& r* �putI s
z Session.putc K s | 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
ZPATCHr� )rh )r; rN r� r� r& r& r* �patchU s
z
Session.patchc K s | j d|f|�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
ZDELETE)rh )r; rN r� r& r& r* �deletea s zSession.deletec
K s~ |j d| j� |j d| j� |j d| j� |j d| j� t|t�rJtd��|jdd�}|j d�}|j
}| j |j d�}t
� }|j|f|�}t
� | } t| d �|_td
||f|�}|jr�x |jD ]}
t| j|
j|
j� q�W t| j||j� | j||f|�} |�r
d d � | D �ng } | �r.| jd
|� | j� }| |_|�sny"t| j||fddi|���|_W n tk
�rl Y nX |�sz|j |S )zISend a given PreparedRequest.
:rtype: requests.Response
rH rJ rK rL z#You can only send PreparedRequests.rM T)rN )Zsecondsr2 c S s g | ]}|�qS r& r& )r' r< r& r& r* r+ � s z Session.send.<locals>.<listcomp>r rd ) rl rH rJ rK rL r, r �
ValueErrorr] r3 rx � get_adapterrN �preferred_clockrb r �elapsedr rQ r r_ rh rT rg �insert�nextZ_next�
StopIterationrR )
r; rh r� rM rH rx �adapter�start�rr� r< �genrQ r& r& r* rb k sB
"z Session.sendc
C s� | j rr|dk r|jd�nd}t||d�}x |j� D ]\}} |j|| � q2W |dksZ|dkrrtjjd�pptjjd�}t|| j�}t|| j �}t|| j
�}t|| j �}||||d�S )z^
Check the environment and merge it with some settings.
:rtype: dict
Nrj )rj TZREQUESTS_CA_BUNDLEZCURL_CA_BUNDLE)rJ rL rH rK ) ri r3 r r. rl �os�environr1 rL rH rJ rK )
r; rN rL rH rJ rK rj Z env_proxiesr( r) r& r& r* r� � s z"Session.merge_environment_settingsc C s> x,| j j� D ] \}}|j� j|j� �r |S q W td| ��dS )z~
Returns the appropriate connection adapter for the given URL.
:rtype: requests.adapters.BaseAdapter
z*No connection adapters were found for '%s'N)rz r. �lowerrY r )r; rN �prefixr� r& r& r* r� � s zSession.get_adapterc C s x| j j� D ] }|j� q W dS )z+Closes all adapters and as such the sessionN)rz �valuesrX )r; r) r& r& r* rX � s z
Session.closec sB || j � < � fdd�| j D �}x |D ]}| j j|�| j |< q$W dS )zwRegisters a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
c s g | ]}t |�t � �k r|�qS r& )rV )r' r( )r� r& r* r+ � s z!Session.mount.<locals>.<listcomp>N)rz r] )r; r� r� Z keys_to_mover0 r& )r� r* r{ � s
z
Session.mountc s � fdd�� j D �}|S )Nc s i | ]}t � |d �|�qS )N)�getattr)r' �attr)r; r& r* �
<dictcomp>� s z(Session.__getstate__.<locals>.<dictcomp>)� __attrs__)r; �stater& )r; r* � __getstate__� s zSession.__getstate__c C s& x |j � D ]\}}t| ||� q
W d S )N)r. �setattr)r; r� r� �valuer& r& r* � __setstate__� s zSession.__setstate__)NNNNNNNTNNNNNN)NN)N)N)rs rt ru �__doc__r� r| r} r r� rh r3 r� r� r� r� r� r� rb r� r� rX r{ r� r� r& r& r& r* rv V s2
7)
D
I rv c C s 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
)rv r& r& r& r* �session� s r� )>r� r� �sysZtimeZdatetimer rw r �compatr r r r r r
r_ r r r
r Zmodelsr r r rx r r Z_internal_utilsr Zutilsr r r �
exceptionsr r r r Z
structuresr rz r r r r r! r" r# Z status_codesr$ r% �platformZ perf_counterr� �AttributeErrorZclockr1 r4 �objectr5 rv r� r& r& r& r* �<module> s@
x % __pycache__/auth.cpython-36.opt-1.pyc 0000644 00000020107 15173103335 0013303 0 ustar 00 3
��[�' � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
m Z m Z ddl
mZ ddlmZ ddlmZ d Zd
Zd d � ZG d
d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z]
requests.auth
~~~~~~~~~~~~~
This module contains the authentication handlers for Requests.
� N)� b64encode� )�urlparse�str�
basestring)�extract_cookies_to_jar)�to_native_string)�parse_dict_headerz!application/x-www-form-urlencodedzmultipart/form-datac C s� t | t�s&tjdj| �td� t| �} t |t�sLtjdj|�td� t|�}t | t�r`| jd�} t |t�rt|jd�}dtt dj
| |f��j � � }|S )z Returns a Basic Auth string.z�Non-string usernames will no longer be supported in Requests 3.0.0. Please convert the object you've passed in ({!r}) to a string or bytes object in the near future to avoid problems.)�categoryz�Non-string passwords will no longer be supported in Requests 3.0.0. Please convert the object you've passed in ({!r}) to a string or bytes object in the near future to avoid problems.�latin1zBasic � :) �
isinstancer �warnings�warn�format�DeprecationWarningr �encoder r �join�strip)�username�passwordZauthstr� r �/usr/lib/python3.6/auth.py�_basic_auth_str s&
r c @ s e Zd ZdZdd� ZdS )�AuthBasez4Base class that all auth implementations derive fromc C s t d��d S )Nz Auth hooks must be callable.)�NotImplementedError)�self�rr r r �__call__K s zAuthBase.__call__N)�__name__�
__module__� __qualname__�__doc__r r r r r r H s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �
HTTPBasicAuthz?Attaches HTTP Basic Authentication to the given Request object.c C s || _ || _d S )N)r r )r r r r r r �__init__R s zHTTPBasicAuth.__init__c C s( t | jt|dd �k| jt|dd �kg�S )Nr r )�allr �getattrr )r �otherr r r �__eq__V s zHTTPBasicAuth.__eq__c C s
| |k S )Nr )r r' r r r �__ne__\ s zHTTPBasicAuth.__ne__c C s t | j| j�|jd< |S )N�
Authorization)r r r �headers)r r r r r r _ s zHTTPBasicAuth.__call__N)r r r! r" r$ r( r) r r r r r r# O s
r# c @ s e Zd ZdZdd� ZdS )�
HTTPProxyAuthz=Attaches HTTP Proxy Authentication to a given Request object.c C s t | j| j�|jd< |S )NzProxy-Authorization)r r r r+ )r r r r r r g s zHTTPProxyAuth.__call__N)r r r! r" r r r r r r, d s r, c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dS )�HTTPDigestAuthz@Attaches HTTP Digest Authentication to the given Request object.c C s || _ || _tj� | _d S )N)r r � threadingZlocal�
_thread_local)r r r r r r r$ o s zHTTPDigestAuth.__init__c C s@ t | jd�s<d| j_d| j_d| j_i | j_d | j_d | j_d S )N�initT� r )�hasattrr/ r0 �
last_nonce� nonce_count�chal�pos�
num_401_calls)r r r r �init_per_thread_stateu s z$HTTPDigestAuth.init_per_thread_statec s� | j jd }| j jd }| j jjd�}| j jjd�}| j jjd�}d� |dkrTd}n|j� }|dksl|dkrzd d
� } | � n@|d kr�d d
� }
|
� n*|dkr�dd� } | � n|dkr�dd� } | � � fdd�}
� dkr�dS d}t|�}|jp�d}|jr�|d|j 7 }d| j|| jf }d||f }� |�}� |�}|| j j k�rJ| j j
d7 _
nd| j _
d| j j
}t | j j
�j d �}||j d �7 }|t
j� j d �7 }|tjd �7 }tj|�j� dd � }|dk�rЈ d|||f �}|�s�|
|d||f �}n<|d k�sd |jd �k�r"d!|||d |f }|
||�}ndS || j _ d"| j||||f }|�rT|d#| 7 }|�rf|d$| 7 }|�rx|d%| 7 }|�r�|d&||f 7 }d'| S )(z
:rtype: str
�realm�nonce�qop� algorithm�opaqueNZMD5zMD5-SESSc S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r �hashlibZmd5� hexdigest)�xr r r �md5_utf8� s
z4HTTPDigestAuth.build_digest_header.<locals>.md5_utf8ZSHAc S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> �sha1r? )r@ r r r �sha_utf8� s
z4HTTPDigestAuth.build_digest_header.<locals>.sha_utf8zSHA-256c S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> Zsha256r? )r@ r r r � sha256_utf8� s
z7HTTPDigestAuth.build_digest_header.<locals>.sha256_utf8zSHA-512c S s" t | t�r| jd�} tj| �j� S )Nzutf-8)r
r r r> Zsha512r? )r@ r r r � sha512_utf8� s
z7HTTPDigestAuth.build_digest_header.<locals>.sha512_utf8c s � d| |f �S )Nz%s:%sr )�s�d)� hash_utf8r r �<lambda>� s z4HTTPDigestAuth.build_digest_header.<locals>.<lambda>�/�?z%s:%s:%sz%s:%sr z%08xzutf-8� � Zauth�,z%s:%s:%s:%s:%sz>username="%s", realm="%s", nonce="%s", uri="%s", response="%s"z
, opaque="%s"z, algorithm="%s"z
, digest="%s"z , qop="auth", nc=%s, cnonce="%s"z Digest %s)r/ r5 �get�upperr �pathZqueryr r r3 r4 r r �timeZctime�os�urandomr> rB r? �split)r �method�urlr9 r: r; r< r= Z
_algorithmrA rC rD rE ZKDZentdigZp_parsedrQ ZA1ZA2ZHA1ZHA2ZncvaluerF ZcnonceZrespdigZnoncebit�baser )rH r �build_digest_header s~
z"HTTPDigestAuth.build_digest_headerc K s |j rd| j_dS )z)Reset num_401_calls counter on redirects.r N)Z is_redirectr/ r7 )r r �kwargsr r r �handle_redirect� s z HTTPDigestAuth.handle_redirectc K s" d|j kodk n s&d| j_|S | jjdk rD|jjj| jj� |jjdd�}d|j � koh| jjdk �r| j jd7 _t
j d t
j d
�}t
|jd|dd ��| j_|j |j� |jj� }t|j|j|j� |j|j� | j|j|j�|jd < |jj|f|�}|j j |� ||_|S d| j_|S )
zo
Takes the given response and tries digest-auth, if needed.
:rtype: requests.Response
i� i� r Nzwww-authenticater1 Zdigest� zdigest )�flags)�countr* ) Z status_coder/ r7 r6 Zrequest�body�seekr+ rO �lower�re�compile�
IGNORECASEr �subr5 Zcontent�close�copyr Z_cookies�rawZprepare_cookiesrY rV rW Z
connection�send�history�append)r r rZ Zs_authZpatZprepZ_rr r r �
handle_401� s.
zHTTPDigestAuth.handle_401c C s~ | j � | jjr&| j|j|j�|jd< y|jj� | j_ W n t
k
rT d | j_ Y nX |j d| j � |j d| j
� d| j_|S )Nr* Zresponser )r8 r/ r3 rY rV rW r+ r_ �tellr6 �AttributeErrorZ
register_hookrl r[ r7 )r r r r r r s zHTTPDigestAuth.__call__c C s( t | jt|dd �k| jt|dd �kg�S )Nr r )r% r r& r )r r' r r r r( * s zHTTPDigestAuth.__eq__c C s
| |k S )Nr )r r' r r r r) 0 s zHTTPDigestAuth.__ne__N) r r r! r" r$ r8 rY r[ rl r r( r) r r r r r- l s
f,r- )r" rS rb rR r> r. r �base64r �compatr r r Zcookiesr Z_internal_utilsr Zutilsr Z CONTENT_TYPE_FORM_URLENCODEDZCONTENT_TYPE_MULTI_PARTr �objectr r# r, r- r r r r �<module> s$ , __pycache__/certs.cpython-36.opt-1.pyc 0000644 00000001553 15173103335 0013466 0 ustar 00 3
|`�h� � @ sH d Z yddlmZ W n ek
r0 dd� ZY nX edkrDee� � dS )u�
requests.certs
~~~~~~~~~~~~~~
This module returns the preferred default CA certificate bundle. There is
only one — the one from the certifi package.
If you are packaging Requests, e.g., for a Linux distribution or a managed
environment, you can change the definition of where() to return a separately
packaged CA bundle.
This Fedora-patched package returns "/etc/pki/tls/certs/ca-bundle.crt" provided
by the ca-certificates RPM package.
� )�wherec C s dS )z1Return the absolute path to the system CA bundle.z /etc/pki/tls/certs/ca-bundle.crt� r r r �/usr/lib/python3.6/certs.pyr s r �__main__N)�__doc__Zcertifir � ImportError�__name__�printr r r r �<module> s __pycache__/exceptions.cpython-36.opt-1.pyc 0000644 00000012450 15173103335 0014525 0 ustar 00 3
��[q � @ s� d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d
� d
e�ZG d d � d e�ZG d
d� de�Z G dd� dee �Z
G dd� de �Z G dd� de�Z G dd� de�Z
G dd� dee�ZG dd� dee�ZG dd � d ee�ZG d d � d ee�ZG d d � d e�ZG d!d"� d"e�ZG d#d$� d$ee�ZG d%d&� d&ee�ZG d'd(� d(e�ZG d)d*� d*e�ZG d+d,� d,e�ZG d-d.� d.ee �Z G d/d0� d0e�Z d1S )2z`
requests.exceptions
~~~~~~~~~~~~~~~~~~~
This module contains the set of Requests' exceptions.
� )� HTTPErrorc s e Zd ZdZ� fdd�Z� ZS )�RequestExceptionzTThere was an ambiguous exception that occurred while handling your
request.
c sZ |j dd�}|| _|j dd�| _|dk rD| j rDt|d�rD| jj| _tt| �j||� dS )zBInitialize RequestException with `request` and `response` objects.�responseN�request)�popr r �hasattr�superr �__init__)�self�args�kwargsr )� __class__� � /usr/lib/python3.6/exceptions.pyr s
zRequestException.__init__)�__name__�
__module__� __qualname__�__doc__r �
__classcell__r r )r
r r s r c @ s e Zd ZdZdS )r zAn HTTP error occurred.N)r r r r r r r r r s r c @ s e Zd ZdZdS )�ConnectionErrorz A Connection error occurred.N)r r r r r r r r r s r c @ s e Zd ZdZdS )�
ProxyErrorzA proxy error occurred.N)r r r r r r r r r $ s r c @ s e Zd ZdZdS )�SSLErrorzAn SSL error occurred.N)r r r r r r r r r ( s r c @ s e Zd ZdZdS )�Timeoutz�The request timed out.
Catching this error will catch both
:exc:`~requests.exceptions.ConnectTimeout` and
:exc:`~requests.exceptions.ReadTimeout` errors.
N)r r r r r r r r r , s r c @ s e Zd ZdZdS )�ConnectTimeoutz�The request timed out while trying to connect to the remote server.
Requests that produced this error are safe to retry.
N)r r r r r r r r r 5 s r c @ s e Zd ZdZdS )� ReadTimeoutz@The server did not send any data in the allotted amount of time.N)r r r r r r r r r < s r c @ s e Zd ZdZdS )� URLRequiredz*A valid URL is required to make a request.N)r r r r r r r r r @ s r c @ s e Zd ZdZdS )�TooManyRedirectszToo many redirects.N)r r r r r r r r r D s r c @ s e Zd ZdZdS )�
MissingSchemaz/The URL schema (e.g. http or https) is missing.N)r r r r r r r r r H s r c @ s e Zd ZdZdS )�
InvalidSchemaz"See defaults.py for valid schemas.N)r r r r r r r r r L s r c @ s e Zd ZdZdS )�
InvalidURLz%The URL provided was somehow invalid.N)r r r r r r r r r P s r c @ s e Zd ZdZdS )�
InvalidHeaderz.The header value provided was somehow invalid.N)r r r r r r r r r T s r c @ s e Zd ZdZdS )�InvalidProxyURLz"The proxy URL provided is invalid.N)r r r r r r r r r! X s r! c @ s e Zd ZdZdS )�ChunkedEncodingErrorz?The server declared chunked encoding but sent an invalid chunk.N)r r r r r r r r r" \ s r" c @ s e Zd ZdZdS )�ContentDecodingErrorz!Failed to decode response contentN)r r r r r r r r r# ` s r# c @ s e Zd ZdZdS )�StreamConsumedErrorz2The content for this response was already consumedN)r r r r r r r r r$ d s r$ c @ s e Zd ZdZdS )�
RetryErrorzCustom retries logic failedN)r r r r r r r r r% h s r% c @ s e Zd ZdZdS )�UnrewindableBodyErrorz:Requests encountered an error when trying to rewind a bodyN)r r r r r r r r r& l s r& c @ s e Zd ZdZdS )�RequestsWarningzBase warning for Requests.N)r r r r r r r r r' r s r' c @ s e Zd ZdZdS )�FileModeWarningzJA file was opened in text mode, but Requests determined its binary length.N)r r r r r r r r r( w s r( c @ s e Zd ZdZdS )�RequestsDependencyWarningz@An imported dependency doesn't match the expected version range.N)r r r r r r r r r) | s r) N) r Zurllib3.exceptionsr Z
BaseHTTPError�IOErrorr r r r r r r r r �
ValueErrorr r r r r! r" r# � TypeErrorr$ r% r& �Warningr' �DeprecationWarningr( r) r r r r �<module> s0 __pycache__/__init__.cpython-36.opt-1.pyc 0000644 00000005653 15173103335 0014112 0 ustar 00 3
|`�h �
@ s� d Z ddlZddlZddlZddlmZ dd� Zdd� Zyeejej� W n0 e e
fk
rz ej d j ejej�e� Y nX dd
l
mZ ejd e� dd lmZmZmZmZ dd
lmZmZmZmZ ddlmZmZ ddlmZ ddlmZ ddl m Z m Z m Z ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddlm.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 ddl7Z7ddl7m8Z8 e7j9e:�j;e8� � ejde4dd� dS )a�
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings. Basic GET
usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> 'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('https://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key2": "value2",
"key1": "value1"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at <http://python-requests.org>.
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
� N� )�RequestsDependencyWarningc C s~ | j d�} t| �dkr | jd� | \}}}t|�t|�t|� }}}|j d�d d� \}}}t|�t|�t|� }}}d S )N�.� �0� )�split�len�append�int)Zurllib3_versionZchardet_version�major�minor�patch� r � /usr/lib/python3.6/__init__.py�check_compatibility1 s
r c C sV yt tt| jd���} W n tk
r, d S X | dddgk rRdj| �}tj|t� d S )Nr r r � z4Old version of cryptography ({}) may cause slowdown.) �list�mapr r �
ValueError�format�warnings�warnr )Zcryptography_versionZwarningr r r �_check_cryptographyJ s
r z?urllib3 ({}) or chardet ({}) doesn't match a supported version!)�DependencyWarning�ignore)� __title__�__description__�__url__� __version__)� __build__�
__author__�__author_email__� __license__)�
__copyright__�__cake__)�utils)�packages)�Request�Response�PreparedRequest)�request�get�head�postr �put�delete�options)�session�Session)�codes) �RequestException�Timeout� URLRequired�TooManyRedirects� HTTPError�ConnectionError�FileModeWarning�ConnectTimeout� ReadTimeout)� NullHandler�defaultT)r
)<�__doc__Zurllib3Zchardetr �
exceptionsr r r r �AssertionErrorr r r Zurllib3.exceptionsr � simplefilterr r r r r! r" r# r$ r% � r& r' Zmodelsr( r) r* Zapir+ r, r- r. r r/ r0 r1 Zsessionsr2 r3 Z status_codesr4 r5 r6 r7 r8 r9 r: r; r< r= Zloggingr> Z getLogger�__name__Z
addHandlerr r r r �<module>) s8
( , __pycache__/certs.cpython-36.pyc 0000644 00000001553 15173103335 0012527 0 ustar 00 3
|`�h� � @ sH d Z yddlmZ W n ek
r0 dd� ZY nX edkrDee� � dS )u�
requests.certs
~~~~~~~~~~~~~~
This module returns the preferred default CA certificate bundle. There is
only one — the one from the certifi package.
If you are packaging Requests, e.g., for a Linux distribution or a managed
environment, you can change the definition of where() to return a separately
packaged CA bundle.
This Fedora-patched package returns "/etc/pki/tls/certs/ca-bundle.crt" provided
by the ca-certificates RPM package.
� )�wherec C s dS )z1Return the absolute path to the system CA bundle.z /etc/pki/tls/certs/ca-bundle.crt� r r r �/usr/lib/python3.6/certs.pyr s r �__main__N)�__doc__Zcertifir � ImportError�__name__�printr r r r �<module> s __pycache__/sessions.cpython-36.pyc 0000644 00000045651 15173103335 0013264 0 ustar 00 3
|`�hUs � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z m
Z
m Z m Z m
Z
mZ ddlmZmZmZmZ ddlmZmZmZ dd lmZmZ dd
lm Z dd l m Z m Z m Z dd l!m"Z"m#Z#m$Z$m%Z% dd
l&m'Z' ddl(m)Z) ddl m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1 ddlm2Z2 ej3dk�rNy
ej4Z5W n e6k
�rJ ej7Z5Y nX nejZ5e fdd�Z8e fdd�Z9G dd� de:�Z;G dd� de;�Z<dd � Z=dS ) z�
requests.session
~~~~~~~~~~~~~~~~
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
� N)� timedelta� )�_basic_auth_str)� cookielib�is_py3� OrderedDict�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_STATIZwin32c C st |dkr | S | dkr|S t |t�o*t | t�s0| S |t|��}|jt| �� dd� |j� D �}x|D ]
}||= qbW |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 S s g | ]\}}|d kr|�qS )N� )�.0�k�vr& r& � /usr/lib/python3.6/sessions.py�
<listcomp>I s z!merge_setting.<locals>.<listcomp>)�
isinstancer
r �update�items)Zrequest_settingZsession_setting�
dict_classZmerged_settingZ none_keys�keyr& r& r* �
merge_setting1 s
r1 c C s@ |dks|j d�g kr| S | dks0| j d�g kr4|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)�getr1 )Z
request_hooksZ
session_hooksr/ r& r& r* � merge_hooksP s
r4 c @ s> e Zd Zdd� Zdd� Zddd �Zd
d � Zd d
� Zdd� ZdS )�SessionRedirectMixinc C s, |j r(|jd }tr |jd�}t|d�S dS )z7Receives a Response. Returns a redirect URI or ``None``�location�latin1�utf8N)Z is_redirect�headersr �encoder )�self�respr6 r& r& r* �get_redirect_targeta s
z(SessionRedirectMixin.get_redirect_targetc C s� t |�}t |�}|j|jkr dS |jdkrL|jdkrL|jdkrL|jd krLdS |j|jk}|j|jk}tj|jd�df}| r�|j|kr�|j|kr�dS |p�|S )
zFDecide whether Authorization header should be removed when redirectingTZhttp�P N�https� F)r> N)r@ N)r Zhostname�schemeZportr r3 )r; Zold_urlZnew_urlZ
old_parsedZ
new_parsedZ changed_portZchanged_schemeZ default_portr& r& r* �should_strip_authv s
z&SessionRedirectMixin.should_strip_authFNTc k sd g }
| j |�} t|j�j} �xB| �r^|j� }
|
j|� |
dd� |_y
|j W n( tt t
fk
rv |j j dd� Y nX t
|j�| jkr�td| j |d��|j� | jd�r�t|j�}dt|j�| f } t| �}|jd kr�| r�|j| d
�}n |jr�|j} |j� } |j�st|jt| ��} nt| �} t| �|
_| j|
|� |jtj tj fk�rtd}x |D ]}|
j j |d� �qVW d|
_ |
j }y
|d= W n t!k
�r� Y nX t"|
j#||j � t$|
j#| j%� |
j&|
j#� | j'|
|�}| j(|
|� |
j)dk �o�d |k�p�d
|k}|�r
t*|
� |
}|�r |V q | j+|f|||||dd�| ��}t"| j%|
|j � | j |�} |V q W dS )zBReceives a Response. Returns a generator of Responses or Requests.r NF)Zdecode_contentzExceeded %s redirects.)r2 z//z%s:%s� )�fragment�Content-Length� Content-Type�Transfer-EncodingZCookie)�stream�timeout�verify�cert�proxies�allow_redirects)rE rF rG ),r= r �urlrD �copy�append�history�contentr r � RuntimeError�raw�read�len�
max_redirectsr �close�
startswithr rA �_replaceZgeturlZnetlocr r �rebuild_method� status_coder$ Ztemporary_redirectZpermanent_redirectr9 �popZbody�KeyErrorr Z_cookiesr �cookiesZprepare_cookies�rebuild_proxies� rebuild_authZ_body_positionr# �send)r; r< �reqrH rI rJ rK rL �yield_requestsZadapter_kwargsZhistrN Zprevious_fragment�prepared_requestZ parsed_rurlZparsedZpurged_headers�headerr9 Z
rewindabler& r& r* �resolve_redirects� s|
z&SessionRedirectMixin.resolve_redirectsc C sR |j }|j}d|kr*| j|jj|�r*|d= | jr8t|�nd}|dk rN|j|� 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.
Z
AuthorizationN)r9 rN rB �request� trust_envr Z prepare_auth)r; re r2 r9 rN Znew_authr& r& r* ra s
z!SessionRedirectMixin.rebuild_authc
C s� |dk r |ni }|j }|j}t|�j}|j� }|jd�}t||d�}| jr~| r~t||d�} | j|| jd��}
|
r~|j ||
� d|kr�|d= yt
|| �\} } W n t k
r� d\} } Y nX |j d� r�| r�| r�t
| | �|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)rj �allzProxy-Authorizationr? )NN)r9 rN r rA rO r3 r! ri r �
setdefaultr" r^ rY r )
r; re rL r9 rN rA Z new_proxiesrj Z bypass_proxyZenviron_proxies�proxyZusernameZpasswordr& r& r* r` s*
z$SessionRedirectMixin.rebuild_proxiesc C sX |j }|jtjkr |dkr d}|jtjkr6|dkr6d}|jtjkrN|dkrNd}||_ 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$ Z see_other�foundZmoved)r; re r2 rq r& r& r* r[ ? s z#SessionRedirectMixin.rebuild_method)FNTNNF) �__name__�
__module__� __qualname__r= rB rg ra r` r[ r& r& r& r* r5 _ s
p+r5 c @ s� e Zd ZdZdddddddd d
d d d
dg
Zdd� Zdd� Zdd� Zdd� Zd7dd�Z dd � Z
d d � Z d d � Z d8d!d"�Z
d9d#d$�Zd:d%d&�Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� 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]>
r9 r_ �authrL �hooks�paramsrJ rK Zprefetch�adaptersrH ri rW c C sr t � | _d | _i | _t� | _i | _d| _d| _d | _ t
| _ d| _ t
i �| _t� | _| jdt� � | jdt� � d S )NFTzhttps://zhttp://)r r9 rw rL r rx ry rH rJ rK r rW ri r r_ r rz �mountr )r; r& r& r* �__init__o s
zSession.__init__c C s | S )Nr& )r; r& r& r* � __enter__� s zSession.__enter__c G s | j � d S )N)rX )r; �argsr& r& r* �__exit__� s zSession.__exit__c
C s� |j pi }t|tj�s t|�}ttt� | j �|�}|j}| jrV| rV| j rVt |j
�}t � }|j |j
j� |j
|j|j|jt|j| jtd�t|j| j�t|| j�|t|j| j�d�
|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
)r/ )
rq rN �files�data�jsonr9 ry rw r_ rx )r_ r, r Z CookieJarr r r
rw ri r rN r Zpreparerq �upperr� r� r� r1 r9 r ry r4 rx )r; rh r_ Zmerged_cookiesrw �pr& r& r* �prepare_request� s*
zSession.prepare_requestNTc C st t |j� ||||pi ||p i ||| d�
}| j|�}| p8i } | j|j| |
||�}| |
d�}|j|� | j|f|�}|S )a 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``.
:param cert: (optional) if String, path to ssl client cert file (.pem).
If Tuple, ('cert', 'key') pair.
:rtype: requests.Response
)
rq rN r9 r� r� r� ry rw r_ rx )rI rM )r r� r� �merge_environment_settingsrN r- rb )r; rq rN ry r� r9 r_ r� rw rI rM rL rx rH rJ rK r� rc ZprepZsettingsZ send_kwargsr< r& r& r* rh � s( )
zSession.requestc K s |j dd� | jd|f|�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
rM Tro )rl rh )r; rN �kwargsr& r& r* r3 s z Session.getc K s |j dd� | jd|f|�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
rM TZOPTIONS)rl rh )r; rN r� r& r& r* �options& s zSession.optionsc K s |j dd� | jd|f|�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
rM Frn )rl rh )r; rN r� r& r& r* �head1 s z Session.headc K s | 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
rp )r� r� )rh )r; rN r� r� r� r& r& r* �post< s z Session.postc K s | 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
ZPUTr� )rh )r; rN r� r� r& r& r* �putI s
z Session.putc K s | 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
ZPATCHr� )rh )r; rN r� r� r& r& r* �patchU s
z
Session.patchc K s | j d|f|�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
ZDELETE)rh )r; rN r� r& r& r* �deletea s zSession.deletec
K s~ |j d| j� |j d| j� |j d| j� |j d| j� t|t�rJtd��|jdd�}|j d�}|j
}| j |j d�}t
� }|j|f|�}t
� | } t| d �|_td
||f|�}|jr�x |jD ]}
t| j|
j|
j� q�W t| j||j� | j||f|�} |�r
d d � | D �ng } | �r.| jd
|� | j� }| |_|�sny"t| j||fddi|���|_W n tk
�rl Y nX |�sz|j |S )zISend a given PreparedRequest.
:rtype: requests.Response
rH rJ rK rL z#You can only send PreparedRequests.rM T)rN )Zsecondsr2 c S s g | ]}|�qS r& r& )r' r< r& r& r* r+ � s z Session.send.<locals>.<listcomp>r rd ) rl rH rJ rK rL r, r �
ValueErrorr] r3 rx � get_adapterrN �preferred_clockrb r �elapsedr rQ r r_ rh rT rg �insert�nextZ_next�
StopIterationrR )
r; rh r� rM rH rx �adapter�start�rr� r< �genrQ r& r& r* rb k sB
"z Session.sendc
C s� | j rr|dk r|jd�nd}t||d�}x |j� D ]\}} |j|| � q2W |dksZ|dkrrtjjd�pptjjd�}t|| j�}t|| j �}t|| j
�}t|| j �}||||d�S )z^
Check the environment and merge it with some settings.
:rtype: dict
Nrj )rj TZREQUESTS_CA_BUNDLEZCURL_CA_BUNDLE)rJ rL rH rK ) ri r3 r r. rl �os�environr1 rL rH rJ rK )
r; rN rL rH rJ rK rj Z env_proxiesr( r) r& r& r* r� � s z"Session.merge_environment_settingsc C s> x,| j j� D ] \}}|j� j|j� �r |S q W td| ��dS )z~
Returns the appropriate connection adapter for the given URL.
:rtype: requests.adapters.BaseAdapter
z*No connection adapters were found for '%s'N)rz r. �lowerrY r )r; rN �prefixr� r& r& r* r� � s zSession.get_adapterc C s x| j j� D ] }|j� q W dS )z+Closes all adapters and as such the sessionN)rz �valuesrX )r; r) r& r& r* rX � s z
Session.closec sB || j � < � fdd�| j D �}x |D ]}| j j|�| j |< q$W dS )zwRegisters a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
c s g | ]}t |�t � �k r|�qS r& )rV )r' r( )r� r& r* r+ � s z!Session.mount.<locals>.<listcomp>N)rz r] )r; r� r� Z keys_to_mover0 r& )r� r* r{ � s
z
Session.mountc s � fdd�� j D �}|S )Nc s i | ]}t � |d �|�qS )N)�getattr)r' �attr)r; r& r* �
<dictcomp>� s z(Session.__getstate__.<locals>.<dictcomp>)� __attrs__)r; �stater& )r; r* � __getstate__� s zSession.__getstate__c C s& x |j � D ]\}}t| ||� q
W d S )N)r. �setattr)r; r� r� �valuer& r& r* � __setstate__� s zSession.__setstate__)NNNNNNNTNNNNNN)NN)N)N)rs rt ru �__doc__r� r| r} r r� rh r3 r� r� r� r� r� r� rb r� r� rX r{ r� r� r& r& r& r* rv V s2
7)
D
I rv c C s 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
)rv r& r& r& r* �session� s r� )>r� r� �sysZtimeZdatetimer rw r �compatr r r r r r
r_ r r r
r Zmodelsr r r rx r r Z_internal_utilsr Zutilsr r r �
exceptionsr r r r Z
structuresr rz r r r r r! r" r# Z status_codesr$ r% �platformZ perf_counterr� �AttributeErrorZclockr1 r4 �objectr5 rv r� r& r& r& r* �<module> s@
x % __pycache__/structures.cpython-36.pyc 0000644 00000010314 15173103335 0013625 0 ustar 00 3
��[� � @ s< d Z ddlmZmZmZ G dd� de�ZG dd� de�ZdS )zO
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
� )� OrderedDict�Mapping�MutableMappingc @ sb e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dS )�CaseInsensitiveDicta� A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
Nc K s& t � | _|d kri }| j|f|� d S )N)r �_store�update)�self�data�kwargs� r � /usr/lib/python3.6/structures.py�__init__( s z CaseInsensitiveDict.__init__c C s ||f| j |j� < d S )N)r �lower)r �key�valuer r r � __setitem__. s z CaseInsensitiveDict.__setitem__c C s | j |j� d S )Nr )r r )r r r r r � __getitem__3 s z CaseInsensitiveDict.__getitem__c C s | j |j� = d S )N)r r )r r r r r � __delitem__6 s z CaseInsensitiveDict.__delitem__c C s dd� | j j� D �S )Nc s s | ]\}}|V qd S )Nr )�.0ZcasedkeyZ mappedvaluer r r � <genexpr>: s z/CaseInsensitiveDict.__iter__.<locals>.<genexpr>)r �values)r r r r �__iter__9 s z CaseInsensitiveDict.__iter__c C s
t | j�S )N)�lenr )r r r r �__len__< s zCaseInsensitiveDict.__len__c C s dd� | j j� D �S )z.Like iteritems(), but with all lowercase keys.c s s | ]\}}||d fV qdS )r Nr )r ZlowerkeyZkeyvalr r r r B s z2CaseInsensitiveDict.lower_items.<locals>.<genexpr>)r �items)r r r r � lower_items? s z CaseInsensitiveDict.lower_itemsc C s0 t |t�rt|�}ntS t| j� �t|j� �kS )N)�
isinstancer r �NotImplemented�dictr )r �otherr r r �__eq__G s
zCaseInsensitiveDict.__eq__c C s t | jj� �S )N)r r r )r r r r �copyP s zCaseInsensitiveDict.copyc C s t t| j� ��S )N)�strr r )r r r r �__repr__S s z CaseInsensitiveDict.__repr__)N)�__name__�
__module__� __qualname__�__doc__r
r r r r r r r r! r# r r r r r
s
r c s< e Zd ZdZd � fdd� Zdd� Zdd� Zd d d
�Z� ZS )
�
LookupDictzDictionary lookup object.Nc s || _ tt| �j� d S )N)�name�superr( r
)r r) )� __class__r r r
Z s zLookupDict.__init__c C s
d| j S )Nz
<lookup '%s'>)r) )r r r r r# ^ s zLookupDict.__repr__c C s | j j|d �S )N)�__dict__�get)r r r r r r a s zLookupDict.__getitem__c C s | j j||�S )N)r, r- )r r �defaultr r r r- f s zLookupDict.get)N)N) r$ r% r& r' r
r# r r- �
__classcell__r r )r+ r r( W s
r( N)r' �compatr r r r r r( r r r r �<module> s J __pycache__/__version__.cpython-36.pyc 0000644 00000000727 15173103335 0013672 0 ustar 00 3
��[� � @ s, d Z dZdZdZdZdZdZdZdZd Z d
S ) ZrequestszPython HTTP for Humans.zhttp://python-requests.orgz2.20.0i z
Kenneth Reitzzme@kennethreitz.orgz
Apache 2.0z Copyright 2018 Kenneth Reitzu ✨ 🍰 ✨N)
Z __title__Z__description__Z__url__� __version__Z __build__�
__author__Z__author_email__Z __license__Z
__copyright__Z__cake__� r r �!/usr/lib/python3.6/__version__.py�<module> s __pycache__/utils.cpython-36.pyc 0000644 00000052743 15173103335 0012556 0 ustar 00 3
|`�hGt � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl m Z ddl
mZ ddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$ dd
l%m&Z& dd l'm(Z(m)Z)m*Z*m+Z+ djZ,ej-� Z.ddd�Z/ej0dk�r2dd� Z1dd� Zdd� Z2dd� Z3dkdd �Z4d d � Z5d d � Z6d!d"� Z7d#d$� Z8d%d&� Z9d'd(� Z:dld)d*�Z;d+d,� Z<d-d.� Z=d/d0� Z>d1d2� Z?d3d4� Z@d5d6� ZAd7d8� ZBd9d:� ZCeDdm�ZEd=d>� ZFd?d@� ZGdAdB� ZHdCdD� ZIdEdF� ZJdGdH� ZKejLdIdJ� �ZMdKdL� ZNdndMdN�ZOdOdP� ZPdodRdS�ZQdTdU� ZRdVdW� ZSdXjTdY�ZUeUdZ ZVeUd[ ZWd\d]� ZXd^d_� ZYd`da� ZZej[db�Z\ej[dc�Z]ddde� Z^dfdg� Z_dhdi� Z`dS )pz�
requests.utils
~~~~~~~~~~~~~~
This module provides utility functions that are used within Requests
that are also useful for external consumption.
� N� )� __version__)�certs)�to_native_string)�parse_http_list)�quote�urlparse�bytes�str� OrderedDict�unquote�
getproxies� proxy_bypass�
urlunparse�
basestring�
integer_types�is_py3�proxy_bypass_environment�getproxies_environment�Mapping)�cookiejar_from_dict)�CaseInsensitiveDict)�
InvalidURL�
InvalidHeader�FileModeWarning�UnrewindableBodyError�.netrc�_netrc�P i� )ZhttpZhttpsZwin32c C s� yt rdd l}ndd l}W n tk
r. dS X y6|j|jd�}t|j|d�d �}|j|d�d }W n tk
rz dS X | s�| r�dS |j d�}xX|D ]P}|dkr�d| kr�d S |j
dd
�}|j
d d �}|j
d
d�}t j || t j
�r�d S q�W dS )Nr Fz;Software\Microsoft\Windows\CurrentVersion\Internet SettingsZ ProxyEnableZ
ProxyOverride�;z<local>�.Tz\.�*z.*�?)r �winreg�_winreg� ImportError�OpenKey�HKEY_CURRENT_USER�intZ QueryValueEx�OSError�split�replace�re�match�I)�hostr# ZinternetSettingsZ proxyEnableZ
proxyOverrideZtest� r0 �/usr/lib/python3.6/utils.py�proxy_bypass_registry/ s8
r2 c C s t � rt| �S t| �S dS )z�Return True, if the host should be bypassed.
Checks proxy settings gathered from the environment, if specified,
or the registry.
N)r r r2 )r/ r0 r0 r1 r V s r c C s t | d�r| j� } | S )z/Returns an internal sequence dictionary update.�items)�hasattrr3 )�dr0 r0 r1 �dict_to_sequenceb s
r6 c C s2 d }d}t | d�r t| �}nbt | d�r.| j}nPt | d�r~y | j� }W n tjk
rZ Y n$X tj|�j}d| jkr~t j
dt � t | d��ry | j � }W n$ t
tfk
r� |d k r�|}Y n\X t | d�o�|d k�ry&| jdd � | j � }| j|p�d� W n t
tfk
�r d}Y nX |d k�r$d}td|| �S )
Nr �__len__�len�fileno�ba% Requests has determined the content-length for this request using the binary size of the file: however, the file has been opened in text mode (i.e. without the 'b' flag in the mode). This may lead to an incorrect content-length. In Requests 3.0, support will be removed for files in text mode.�tell�seek� )r4 r8 r9 �io�UnsupportedOperation�os�fstat�st_size�mode�warnings�warnr r; r) �IOErrorr< �max)�oZ total_lengthZcurrent_positionr9 r0 r0 r1 � super_lenk s@
rI Fc C s� y�ddl m }m} d}xJtD ]B}ytjjdj|��}W n tk
rJ dS X tjj|�r |}P q W |dkrndS t | �}|j
}y6||�j |�} | r�| d r�dnd}
| |
| d fS W n |t fk
r� |r̂ Y nX W n t
tfk
r� Y nX dS )z;Returns the Requests tuple auth for a given url from netrc.r )�netrc�NetrcParseErrorNz~/{}r r= )rJ rK � NETRC_FILESr@ �path�
expanduser�format�KeyError�existsr �hostnameZauthenticatorsrF r% �AttributeError) �urlZ raise_errorsrJ rK Z
netrc_path�f�locZrir/ r Zlogin_ir0 r0 r1 �get_netrc_auth� s2
rW c C sB t | dd�}|r>t|t�r>|d dkr>|d dkr>tjj|�S dS )z0Tries to guess the filename of the given object.�nameNr �<r �>���)�getattr�
isinstancer r@ rM �basename)�objrX r0 r0 r1 �guess_filename� s r` c C s� t jj| �r| S t jj| �\}}x4|rTt jj|� rTt jj|�\}}dj||g�}q"W tj|�sd| S tj|�}||j� kr~| S t j
� }t jj|f|jd��� }t jj|�s�|j ||d�}|S )z�Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
�/)rM ) r@ rM rQ r* �join�zipfileZ
is_zipfileZZipFileZnamelist�tempfileZ
gettempdir�extract)rM �archive�member�prefixZzip_fileZtmpZextracted_pathr0 r0 r1 �extract_zipped_paths� s
ri c C s. | dkr dS t | ttttf�r&td��t| �S )a� Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: need more than 1 value to unpack
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
Nz+cannot encode objects that are not 2-tuples)r] r
r �boolr( �
ValueErrorr )�valuer0 r0 r1 �from_key_val_list� s
rm c C s@ | dkr dS t | ttttf�r&td��t | t�r8| j� } t| �S )a� Take an object and test to see if it can be represented as a
dictionary. If it can be, return a list of tuples, e.g.,
::
>>> to_key_val_list([('key', 'val')])
[('key', 'val')]
>>> to_key_val_list({'key': 'val'})
[('key', 'val')]
>>> to_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples.
:rtype: list
Nz+cannot encode objects that are not 2-tuples) r] r
r rj r( rk r r3 �list)rl r0 r0 r1 �to_key_val_list s
ro c C s\ g }xRt | �D ]F}|dd� |dd� ko4dkn rJt|dd� �}|j|� qW |S )a Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
Nr �"r[ r[ )�_parse_list_header�unquote_header_value�append)rl �result�itemr0 r0 r1 �parse_list_header2 s (rv c C s| i }xrt | �D ]f}d|kr$d||< q|jdd�\}} | dd� | dd� koVdkn rlt| dd� �} | ||< qW |S )a^ Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
�=Nr rp r[ r[ )rq r* rr )rl rt ru rX r0 r0 r1 �parse_dict_headerR s ( rx c C s^ | rZ| d | d ko dkn rZ| dd
� } | sF| dd� dkrZ| j dd�j dd�S | S ) z�Unquotes a header value. (Reversal of :func:`quote_header_value`).
This does not use the real unquoting but what browsers are actually
using for quoting.
:param value: the header value to unquote.
:rtype: str
r r rp Nr= z\\�\z\"r[ r[ )r+ )rl Z is_filenamer0 r0 r1 rr u s
$ rr c C s" i }x| D ]}|j ||j< q
W |S )z�Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
)rl rX )�cj� cookie_dictZcookier0 r0 r1 �dict_from_cookiejar� s
r| c C s
t || �S )z�Returns a CookieJar from a key/value dictionary.
:param cj: CookieJar to insert cookies into.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:rtype: CookieJar
)r )rz r{ r0 r0 r1 �add_dict_to_cookiejar� s r} c C sT t jdt� tjdtjd�}tjdtjd�}tjd�}|j| �|j| � |j| � S )zlReturns encodings from given content string.
:param content: bytestring to extract encodings from.
z�In requests 3.0, get_encodings_from_content will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)z!<meta.*?charset=["\']*(.+?)["\'>])�flagsz+<meta.*?content=["\']*;?charset=(.+?)["\'>]z$^<\?xml.*?encoding=["\']*(.+?)["\'>])rD rE �DeprecationWarningr, �compiler. �findall)�contentZ
charset_reZ pragma_reZxml_rer0 r0 r1 �get_encodings_from_content� s
r� c
C s� | j d�}|d j� |dd� }}i }d}xh|D ]`}|j� }|r2|d }}|jd�} | dkr�|d| � j|�}|| d d� j|�}|||j� < q2W ||fS ) z�Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
r r r Nz"' Trw r[ )r* �strip�find�lower)
�header�tokens� content_type�paramsZ params_dictZitems_to_strip�param�keyrl Zindex_of_equalsr0 r0 r1 �_parse_content_type_header� s
r� c C sD | j d�}|sdS t|�\}}d|kr4|d jd�S d|kr@dS dS )z}Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
z content-typeN�charsetz'"�textz
ISO-8859-1)�getr� r� )�headersr� r� r0 r0 r1 �get_encoding_from_headers� s
r� c c sr |j dkr"x| D ]
}|V qW dS tj|j �dd�}x | D ]}|j|�}|r:|V q:W |jddd�}|rn|V dS )zStream decodes a iterator.Nr+ )�errors� T)�final)�encoding�codecs�getincrementaldecoder�decode)�iterator�rru �decoder�chunk�rvr0 r0 r1 � stream_decode_response_unicode� s
r� c c sL d}|dks|dkr t | �}x*|t | �k rF| ||| � V ||7 }q W dS )z Iterate over slices of a string.r N)r8 )�stringZ slice_length�posr0 r0 r1 � iter_slices� s r� c C sv t jdt� g }t| j�}|rJy t| j|�S tk
rH |j|� Y nX yt| j|dd�S t k
rp | jS X dS )z�Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
z�In requests 3.0, get_unicode_from_response will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)r+ )r� N)
rD rE r r� r� r
r� � UnicodeErrorrs � TypeError)r� Ztried_encodingsr� r0 r0 r1 �get_unicode_from_response s
r� Z4ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz0123456789-._~c
C s� | j d�}x�tdt|��D ]�}|| dd� }t|�dkr�|j� r�ytt|d��}W n tk
rt td| ��Y nX |tkr�||| dd� ||< q�d|| ||< qd|| ||< qW dj |�S ) z�Un-escape any percent-escape sequences in a URI that are unreserved
characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
:rtype: str
�%r r r= � z%Invalid percent-escape sequence: '%s'N� )
r* �ranger8 �isalnum�chrr( rk r �UNRESERVED_SETrb )�uri�parts�i�h�cr0 r0 r1 �unquote_unreserved/ s
r� c C s: d}d}yt t| �|d�S tk
r4 t | |d�S X dS )z�Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
z!#$%&'()*+,/:;=?@[]~z!#$&'()*+,/:;=?@[]~)ZsafeN)r r� r )r� Zsafe_with_percentZsafe_without_percentr0 r0 r1 � requote_uriG s r� c C sl t jdtj| ��d }|jd�\}}t jdtjtt|����d }t jdtj|��d |@ }||@ ||@ kS )z�This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
z=Lr ra )�struct�unpack�socket� inet_atonr* �dotted_netmaskr( )ZipZnetZipaddrZnetaddr�bitsZnetmaskZnetworkr0 r0 r1 �address_in_network] s
r� c C s& ddd| > d A }t jtjd|��S )z�Converts mask from /xx format to xxx.xxx.xxx.xxx
Example: if mask is 24 function returns 255.255.255.0
:rtype: str
l �� r � z>I)r� Z inet_ntoar� �pack)�maskr� r0 r0 r1 r� l s r� c C s* yt j| � W n t jk
r$ dS X dS )z
:rtype: bool
FT)r� r� �error)Z string_ipr0 r0 r1 �is_ipv4_addressw s
r� c C s� | j d�dkr�yt| jd�d �}W n tk
r8 dS X |dk sJ|dkrNdS ytj| jd�d � W q� tjk
r| dS X ndS dS )zV
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
ra r Fr� r T)�countr( r* rk r� r� r� )Zstring_networkr� r0 r0 r1 �
is_valid_cidr� s r� c c sT |dk }|r"t jj| �}|t j| < z
dV W d|rN|dkrDt j| = n
|t j| < X dS )z�Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothingN)r@ �environr� )Zenv_namerl Z
value_changedZ old_valuer0 r0 r1 � set_environ� s
r� c C s, dd� }|}|dkr |d�}t | �}|jdkr2dS |r�dd� |jdd �jd
�D �}t|j�r�xz|D ],}t|�r�t|j|�r�dS qb|j|krbdS qbW nD|j}|jr�|d j|j�7 }x&|D ] }|jj |�s�|j |�r�dS q�W t
d|��6 yt |j�}W n t t
jfk
�r d }Y nX W dQ R X |�r(dS d S )
zL
Returns whether we should bypass proxies or not.
:rtype: bool
c S s t jj| �pt jj| j� �S )N)r@ r� r� �upper)�kr0 r0 r1 �<lambda>� s z'should_bypass_proxies.<locals>.<lambda>N�no_proxyTc s s | ]}|r|V qd S )Nr0 )�.0r/ r0 r0 r1 � <genexpr>� s z(should_bypass_proxies.<locals>.<genexpr>� r� �,z:{}F)r rR r+ r* r� r� r� ZportrO �endswithr� r r� r� Zgaierror) rT r� Z get_proxyZ no_proxy_arg�parsedZproxy_ipZhost_with_portr/ Zbypassr0 r0 r1 �should_bypass_proxies� s<
r� c C s t | |d�ri S t� S dS )zA
Return a dict of environment proxies.
:rtype: dict
)r� N)r� r
)rT r� r0 r0 r1 �get_environ_proxies� s r� c C sv |pi }t | �}|jdkr.|j|j|jd��S |jd |j |jd|j dg}d}x |D ]}||krX|| }P qXW |S )z�Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
N�allz://zall://)r rR r� �scheme)rT ZproxiesZurlpartsZ
proxy_keys�proxyZ proxy_keyr0 r0 r1 � select_proxy� s
r� �python-requestsc C s d| t f S )zO
Return a string representing the default user agent.
:rtype: str
z%s/%s)r )rX r0 r0 r1 �default_user_agent s r� c C s t t� djd�ddd��S )z9
:rtype: requests.structures.CaseInsensitiveDict
z, �gzip�deflatez*/*z
keep-alive)z
User-AgentzAccept-EncodingZAcceptZ
Connection)r� r� )r r� rb r0 r0 r0 r1 �default_headers s
r� c C s� g }d}| j |�} | s|S x�tjd| �D ]�}y|jdd�\}}W n tk
r^ |d }}Y nX d|j d�i}xP|jd�D ]B}y|jd�\}} W n tk
r� P Y nX | j |�||j |�< qzW |j|� q(W |S ) z�Return a list of parsed link headers proxies.
i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"
:rtype: list
z '"z, *<r r r� rT z<> '"rw )r� r, r* rk rs ) rl ZlinksZ
replace_chars�valrT r� �linkr� r� r0 r0 r1 �parse_header_links( s&
r� � �asciir= � c C s� | dd� }|t jt jfkr dS |dd� t jkr6dS |dd� t jt jfkrRdS |jt�}|dkrhd S |dkr�|ddd� tkr�d
S |d dd� tkr�d S |dkr�|dd� t kr�d
S |d d� t kr�dS dS )z
:rtype: str
N� zutf-32r� z utf-8-sigr= zutf-16r zutf-8z utf-16-ber z utf-16-lez utf-32-bez utf-32-le)
r� � BOM_UTF32_LE� BOM_UTF32_BE�BOM_UTF8� BOM_UTF16_LE� BOM_UTF16_BEr� �_null�_null2�_null3)�dataZsampleZ nullcountr0 r0 r1 �guess_json_utfS s*
r� c C s8 t | |�\}}}}}}|s$|| }}t||||||f�S )z�Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
)r r )rT Z
new_schemer� �netlocrM r� �query�fragmentr0 r0 r1 �prepend_scheme_if_neededs s
r� c C sB t | �}yt|j�t|j�f}W n ttfk
r< d}Y nX |S )z{Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
r� )r� r� )r r ZusernameZpasswordrS r� )rT r� Zauthr0 r0 r1 �get_auth_from_url� s
r� s ^\S[^\r\n]*$|^$z^\S[^\r\n]*$|^$c C sf | \}}t |t�rt}nt}y|j|�s4td| ��W n* tk
r` td||t|�f ��Y nX dS )z�Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
z7Invalid return character or leading space in header: %sz>Value for header {%s: %s} must be of type str or bytes, not %sN)r] r �_CLEAN_HEADER_REGEX_BYTE�_CLEAN_HEADER_REGEX_STRr- r r� �type)r� rX rl Zpatr0 r0 r1 �check_header_validity� s
r� c C sF t | �\}}}}}}|s"|| }}|jdd�d }t|||||df�S )zW
Given a url remove the fragment and the authentication part.
:rtype: str
�@r r� r[ )r �rsplitr )rT r� r� rM r� r� r� r0 r0 r1 �
urldefragauth� s
r� c C s` t | jdd�}|dk rTt| jt�rTy|| j� W q\ ttfk
rP td��Y q\X ntd��dS )zfMove file pointer back to its recorded starting position
so it can be read again on redirect.
r< Nz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r\ Zbodyr] Z_body_positionr rF r) r )Zprepared_requestZ body_seekr0 r0 r1 � rewind_body� s r� )r r )F)FzBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~)N)r� )a�__doc__r� �
contextlibr> r@ r, r� r� �sysrd rD rc r r� r Z_internal_utilsr �compatr rq r r r r
r r r
r r r r r r r r Zcookiesr Z
structuresr �
exceptionsr r r r rL �whereZDEFAULT_CA_BUNDLE_PATHZ
DEFAULT_PORTS�platformr2 r6 rI rW r` ri rm ro rv rx rr r| r} r� r� r� r� r� r� � frozensetr� r� r� r� r� r� r� �contextmanagerr� r� r� r� r� r� r� �encoder� r� r� r� r� r� r� r� r� r� r� r� r0 r0 r0 r1 �<module> s� D
' =
- #
% =
&
__pycache__/adapters.cpython-36.opt-1.pyc 0000644 00000053725 15173103335 0014161 0 ustar 00 3
|`�h7q � @ sR d Z ddlZddlZddlZddlmZmZ ddlm Z ddl
m Z ddl
m Z
ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z ddlm Z ddl!m"Z" ddl#m$Z$m%Z% ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3m4Z4m5Z5m Z mZm6Z6m7Z7m8Z8m9Z9 ddl:m;Z; ydd l<m=Z= W n e>k
�r� d d � Z=Y nX d Z?d Z@dZAdZBy ddlCZCe� ZDeDjEe(e'�� W n e>k
�r� dZDY nX d!d"ejFeGejHf eId#�d$d%�ZJd&d!d"d'd(d)�d*d+�ZKG d,d-� d-eL�ZMG d.d/� d/eM�ZNdS )0z�
requests.adapters
~~~~~~~~~~~~~~~~~
This module contains the transport adapters that Requests uses to define
and maintain connections.
� N)� PoolManager�proxy_from_url)� HTTPResponse)� parse_url)�Timeout)�Retry)�create_urllib3_context)�ClosedPoolError)�ConnectTimeoutError)� HTTPError)�
MaxRetryError)�NewConnectionError)�
ProxyError)�
ProtocolError)�ReadTimeoutError)�SSLError)�
ResponseError)�LocationValueError� )�Response)�urlparse�
basestring)�DEFAULT_CA_BUNDLE_PATH�extract_zipped_paths�get_encoding_from_headers�prepend_scheme_if_needed�get_auth_from_url�
urldefragauth� select_proxy)�CaseInsensitiveDict)�extract_cookies_to_jar) �ConnectionError�ConnectTimeout� ReadTimeoutr r �
RetryError�
InvalidSchema�InvalidProxyURL�
InvalidURL)�_basic_auth_str)�SOCKSProxyManagerc O s t d��d S )Nz'Missing dependencies for SOCKS support.)r% )�args�kwargs� r, � /usr/lib/python3.6/adapters.pyr) 0 s r) F�
zbool | str | Nonez#typing.Tuple[str, str] | str | None)�verify� client_cert�poolmanager_kwargs�returnc C s, |j d�}| dko&td k o&| o&|d k}|S )N� ssl_contextT)�get�_preloaded_ssl_context)r/ r0 r1 Zhas_poolmanager_ssl_contextZ should_use_default_ssl_contextr, r, r- �_should_use_default_contextE s
r6 ZPreparedRequestr z<(typing.Dict[str, typing.Any], typing.Dict[str, typing.Any]))�requestr/ r0 � poolmanagerr2 c C s� i }i }t | j�}|jj� }|j}t|di �} d}
d } |dkrDd}
n6t||| �rZt|d< n |dkrltt �} nt
|t �rz|} | d k r�t j
j| �s�| |d< n| |d< |
|d < |d k r�t
|t�r�t|�d
kr�|d |d < |d
|d< n||d < ||j|d�}||fS )NZconnection_pool_kw�
CERT_REQUIREDF� CERT_NONEr3 T�ca_certs� ca_cert_dir� cert_reqs� r � cert_filer �key_file)�scheme�host�port)r �urlrA �lowerrC �getattrr6 r5 r r �
isinstance�str�os�path�isdir�tuple�lenZhostname) r7 r/ r0 r8 � host_params� pool_kwargsZparsed_request_urlrA rC r1 r= �cert_locr, r, r- �_urllib3_request_contextV s<
rQ c s2 e Zd ZdZ� fdd�Zd dd�Zd d
� Z� ZS ) � BaseAdapterzThe Base Transport Adapterc s t t| �j� d S )N)�superrR �__init__)�self)� __class__r, r- rT � s zBaseAdapter.__init__FNTc C s t �dS )aC Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
N)�NotImplementedError)rU r7 �stream�timeoutr/ �cert�proxiesr, r, r- �send� s zBaseAdapter.sendc C s t �dS )z!Cleans up adapter specific items.N)rW )rU r, r, r- �close� s zBaseAdapter.close)FNTNN)�__name__�
__module__� __qualname__�__doc__rT r\ r] �
__classcell__r, r, )rV r- rR � s
rR c s� e Zd ZdZdddddgZeeeef� fdd� Zd d
� Z d d � Z
efd
d�Z dd� Z dd� Z
dd� Zd(dd�Zd)dd�Zd*dd�Zd d � Zd d � Zd d!� Zd"d#� Zd+d&d'�Z� ZS ),� HTTPAdaptera� The built-in HTTP Adapter for urllib3.
Provides a general-case interface for Requests sessions to contact HTTP and
HTTPS urls by implementing the Transport Adapter interface. This class will
usually be created by the :class:`Session <Session>` class under the
covers.
:param pool_connections: The number of urllib3 connection pools to cache.
:param pool_maxsize: The maximum number of connections to save in the pool.
:param max_retries: The maximum number of retries each connection
should attempt. Note, this applies only to failed DNS lookups, socket
connections and connection timeouts, never to requests where data has
made it to the server. By default, Requests does not retry failed
connections. If you need granular control over the conditions under
which we retry a request, import urllib3's ``Retry`` class and pass
that instead.
:param pool_block: Whether the connection pool should block for connections.
Usage::
>>> import requests
>>> s = requests.Session()
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
>>> s.mount('http://', a)
� max_retries�config�_pool_connections�
_pool_maxsize� _pool_blockc sd |t krtddd�| _n tj|�| _i | _i | _tt| �j� || _ || _
|| _ | j |||d� d S )Nr F)�read)�block)
�DEFAULT_RETRIESr rd Zfrom_intre �
proxy_managerrS rc rT rf rg rh �init_poolmanager)rU Zpool_connectionsZ pool_maxsizerd Z
pool_block)rV r, r- rT � s zHTTPAdapter.__init__c s � fdd�� j D �S )Nc s i | ]}t � |d �|�qS )N)rF )�.0�attr)rU r, r- �
<dictcomp>� s z,HTTPAdapter.__getstate__.<locals>.<dictcomp>)� __attrs__)rU r, )rU r- � __getstate__� s zHTTPAdapter.__getstate__c C sH i | _ i | _x |j� D ]\}}t| ||� qW | j| j| j| jd� d S )N)rj )rl re �items�setattrrm rf rg rh )rU �statero �valuer, r, r- � __setstate__� s zHTTPAdapter.__setstate__c K s0 || _ || _|| _tf |||dd�|��| _dS )a Initializes a urllib3 PoolManager.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param connections: The number of urllib3 connection pools to cache.
:param maxsize: The maximum number of connections to save in the pool.
:param block: Block when no free connections are available.
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
T)� num_pools�maxsizerj �strictN)rf rg rh r r8 )rU Z connectionsry rj rO r, r, r- rm � s
z HTTPAdapter.init_poolmanagerc K s� || j kr| j | }n||j� jd�r^t|�\}}t|f||| j| j| jd�|�� }| j |< n4| j|�}t |f|| j| j| jd�|�� }| j |< |S )a� Return urllib3 ProxyManager for the given proxy.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The proxy to return a urllib3 ProxyManager for.
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
:returns: ProxyManager
:rtype: urllib3.ProxyManager
�socks)�username�passwordrx ry rj )�
proxy_headersrx ry rj )
rl rE �
startswithr r) rf rg rh r~ r )rU �proxyZ proxy_kwargsZmanagerr| r} r~ r, r, r- �proxy_manager_for� s*
z HTTPAdapter.proxy_manager_forc C s� |j � jd�rZ|rZd|_|dk rl|}tjj|�s>td|� ���tjj|�sR||_ql||_ nd|_d|_d|_ |r�t
|t �s�|d |_ |d |_
n ||_ d|_
|j r�tjj|j � r�td j|j ���|j
r�tjj|j
� r�td
j|j
���dS ) aA Verify a SSL certificate. This method should not be called from user
code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param conn: The urllib3 connection object associated with the cert.
:param url: The requested URL.
:param verify: 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
:param cert: The SSL certificate to verify.
�httpsr9 TzCCould not find a suitable TLS CA certificate bundle, invalid path: r: Nr r z9Could not find the TLS certificate file, invalid path: {}z1Could not find the TLS key file, invalid path: {})rE r r= rI rJ �exists�OSErrorrK r; r< rG r r? r@ �IOError�format)rU �connrD r/ rZ rP r, r, r- � cert_verify s2
zHTTPAdapter.cert_verifyc C s� t � }t|dd�|_tt|di ��|_t|j�|_||_|jj|_t |j
t �r^|j
j d�|_
n|j
|_
t
|j||� ||_| |_|S )a� Builds a :class:`Response <requests.Response>` object from a urllib3
response. This should not be called from user code, and is only exposed
for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
:param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
:param resp: The urllib3 response object.
:rtype: requests.Response
ZstatusN�headerszutf-8)r rF Z status_coder r� r �encoding�raw�reasonrG rD �bytes�decoder �cookiesr7 �
connection)rU Zreq�respZresponser, r, r- �build_responseL s
zHTTPAdapter.build_responseNc C s t |||| j�S )a� Build the PoolKey attributes used by urllib3 to return a connection.
This looks at the PreparedRequest, the user-specified verify value,
and the value of the cert parameter to determine what PoolKey values
to use to select a connection from a given urllib3 Connection Pool.
The SSL related pool key arguments are not consistently set. As of
this writing, use the following to determine what keys may be in that
dictionary:
* If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the
default Requests SSL Context
* If ``verify`` is ``False``, ``"ssl_context"`` will not be set but
``"cert_reqs"`` will be set
* If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
``"ca_certs"`` will be set if the string is not a directory recognized
by :py:func:`os.path.isdir`, otherwise ``"ca_certs_dir"`` will be
set.
* If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
``"cert"`` is a tuple with a second item, ``"key_file"`` will also
be present
To override these settings, one may subclass this class, call this
method and use the above logic to change parameters as desired. For
example, if one wishes to use a custom :py:class:`ssl.SSLContext` one
must both set ``"ssl_context"`` and based on what else they require,
alter the other keys to ensure the desired behaviour.
:param request:
The PreparedReqest being sent over the connection.
:type request:
:class:`~requests.models.PreparedRequest`
:param verify:
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.
:param cert:
(optional) Any user-provided SSL certificate for client
authentication (a.k.a., mTLS). This may be a string (i.e., just
the path to a file which holds both certificate and key) or a
tuple of length 2 with the certificate file path and key file
path.
:returns:
A tuple of two dictionaries. The first is the "host parameters"
portion of the Pool Key including scheme, hostname, and port. The
second is a dictionary of SSLContext related parameters.
)rQ r8 )rU r7 r/ rZ r, r, r- �$build_connection_pool_key_attributesq s +z0HTTPAdapter.build_connection_pool_key_attributesc C s� t |j|�}y| j|||�\}}W n. tk
rP } zt||d��W Y dd}~X nX |r�t|d�}t|�} | jsvtd��| j |�}
|
j
f |d|i��} n| j j
f |d|i��} | S )ap Returns a urllib3 connection for the given request and TLS settings.
This should not be called from user code, and is only exposed for use
when subclassing the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request:
The :class:`PreparedRequest <PreparedRequest>` object to be sent
over the connection.
:param verify:
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.
:param proxies:
(optional) The proxies dictionary to apply to the request.
:param cert:
(optional) Any user-provided SSL certificate to be used for client
authentication (a.k.a., mTLS).
:rtype:
urllib3.ConnectionPool
)r7 N�httpzFPlease check proxy URL. It is malformed and could be missing the host.rO ) r rD r� �
ValueErrorr' r r rB r& r� Zconnection_from_hostr8 ) rU r7 r/ r[ rZ r� rN rO �e� proxy_urlrl r� r, r, r- � get_connection_with_tls_context� s(
z+HTTPAdapter.get_connection_with_tls_contextc C sd t ||�}|rDt|d�}t|�}|js.td��| j|�}|j|�}n t|�}|j� }| j j|�}|S )a DEPRECATED: Users should move to `get_connection_with_tls_context`
for all subclasses of HTTPAdapter using Requests>=2.32.2.
Returns a urllib3 connection for the given URL. This should not be
called from user code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param url: The URL to connect to.
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
:rtype: urllib3.ConnectionPool
r� zFPlease check proxy URL. It is malformed and could be missing the host.)
r r r rB r& r� Zconnection_from_urlr Zgeturlr8 )rU rD r[ r� r� rl r� Zparsedr, r, r- �get_connection� s
zHTTPAdapter.get_connectionc C s* | j j� x| jj� D ] }|j� qW dS )z�Disposes of any internal state.
Currently, this closes the PoolManager and any active ProxyManager,
which closes any pooled connections.
N)r8 �clearrl �values)rU r� r, r, r- r] � s
zHTTPAdapter.closec C sb t |j|�}t|j�j}|o"|dk}d}|rDt|�jj� }|jd�}|j}|r^| r^t|j�}|S )a? Obtain the url to use when making the final request.
If the message is being sent through a HTTP proxy, the full URL has to
be used. Otherwise, we should only use the path portion of the URL.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
:rtype: str
r� Fr{ )r rD r rA rE r Zpath_urlr ) rU r7 r[ r� rA Zis_proxied_http_requestZusing_socks_proxyZ proxy_schemerD r, r, r- � request_url� s
zHTTPAdapter.request_urlc K s dS )a" Add any headers needed by the connection. As of v2.0 this does
nothing by default, but is left for overriding by users that subclass
the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
:param kwargs: The keyword arguments from the call to send().
Nr, )rU r7 r+ r, r, r- � add_headers s zHTTPAdapter.add_headersc C s& i }t |�\}}|r"t||�|d< |S )a Returns a dictionary of the headers to add to any request sent
through a proxy. This works with urllib3 magic to ensure that they are
correctly sent to the proxy, rather than in a tunnelled request if
CONNECT is being used.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The url of the proxy being used for this request.
:rtype: dict
zProxy-Authorization)r r( )rU r� r� r| r} r, r, r- r~ s
zHTTPAdapter.proxy_headersFTc 7 C s� y| j ||||d�}W n. tk
rD } zt||d��W Y dd}~X nX | j||j||� | j||�} | j||||||d� |jdkp�d|jk }
t |t
�r�y|\} } t | | d�}W n4 t k
r� } zdj
|�}
t |
��W Y dd}~X nX nt |t �r�n t ||d�}�yN|
�s6|j|j| |j|jdddd| j|d �
}�nt|d
��rH|j}|jtd �}y�|j|j| d d
� x$|jj� D ]\}}|j||� �qtW |j� xN|jD ]D}|jtt|��dd� j d�� |jd� |j|� |jd� �q�W |jd� y|j d d�}W n t k
�r |j � }Y nX t j |||ddd�}W n |j!� � Y nX W �n� t"t#j$fk
�r� }
zt%|
|d��W Y dd}
~
X �nZ t&k
�r. } z�t |j't(��r�t |j't)��s�t*||d��t |j't+��r�t,||d��t |j't-��r�t.||d��t |j't/��rt0||d��t%||d��W Y dd}~X n� t1k
�r\ } zt%||d��W Y dd}~X n� t-k
�r� } zt.|��W Y dd}~X n^ t/t2fk
�r� } z<t |t/��r�t0||d��n t |t3��r�t4||d��n� W Y dd}~X nX | j5||�S )a Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 or urllib3 Timeout object
: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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
:rtype: requests.Response
)r[ rZ )r7 N)rX rY r/ rZ r[ zContent-Length)�connectri zrInvalid timeout {}. Pass a (connect, read) timeout tuple, or a single float to set both timeouts to the same valueF)
�methodrD �bodyr� ZredirectZassert_same_host�preload_content�decode_contentZretriesrY �
proxy_pool)rY T)Zskip_accept_encodingr> zutf-8s
s 0
)� buffering)Zpoolr� r� r� )6r� r r' r� rD r� r� r� r� rG rL � TimeoutSaucer� r� Zurlopenr� rd �hasattrr� Z _get_conn�DEFAULT_POOL_TIMEOUTZ
putrequestrs Z putheaderZ
endheadersr\ �hexrM �encodeZ getresponse� TypeErrorr Z from_httplibr] r �socket�errorr! r r� r
r
r" r r$ � _ProxyErrorr � _SSLErrorr r �
_HTTPErrorr r# r� )rU r7 rX rY r/ rZ r[ r� r� rD Zchunkedr� ri �errr� Zlow_conn�headerrv �i�rr, r, r- r\ 5 s�
zHTTPAdapter.send)N)NN)N)FNTNN)r^ r_ r` ra rq �DEFAULT_POOLSIZErk �DEFAULT_POOLBLOCKrT rr rw rm r� r� r� r� r� r� r] r� r� r~ r\ rb r, r, )rV r- rc � s( %3%
-
/
rc )Ora Zos.pathrI r� ZtypingZurllib3.poolmanagerr r Zurllib3.responser Z urllib3.utilr r r� Zurllib3.util.retryr Zurllib3.util.ssl_r Zurllib3.exceptionsr r
r r� r r
r r� r r r r� r r Zmodelsr �compatr r Zutilsr r r r r r r Z
structuresr r� r �
exceptionsr! r" r# r$ r% r& r' Zauthr( Zurllib3.contrib.socksr) � ImportErrorr� r� rk r� Zsslr5 Zload_verify_locationsZDictrH ZAny�boolr6 rQ �objectrR rc r, r, r, r- �<module> sj $ ,
* __pycache__/packages.cpython-36.opt-1.pyc 0000644 00000000541 15173103335 0014120 0 ustar 00 3
��[ � @ sf d dl Z xXdD ]PZee�e� e< x<ee j�D ].ZeeksFejed �r,e je e jde < q,W qW dS )� N�urllib3�idna�chardet�.zrequests.packages.)r r r )�sys�package�
__import__�locals�list�modules�mod�
startswith� r r � /usr/lib/python3.6/packages.py�<module> s
utils.py 0000644 00000072107 15173103335 0006266 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.utils
~~~~~~~~~~~~~~
This module provides utility functions that are used within Requests
that are also useful for external consumption.
"""
import codecs
import contextlib
import io
import os
import re
import socket
import struct
import sys
import tempfile
import warnings
import zipfile
from .__version__ import __version__
from . import certs
# to_native_string is unused here, but imported here for backwards compatibility
from ._internal_utils import to_native_string
from .compat import parse_http_list as _parse_list_header
from .compat import (
quote, urlparse, bytes, str, OrderedDict, unquote, getproxies,
proxy_bypass, urlunparse, basestring, integer_types, is_py3,
proxy_bypass_environment, getproxies_environment, Mapping)
from .cookies import cookiejar_from_dict
from .structures import CaseInsensitiveDict
from .exceptions import (
InvalidURL, InvalidHeader, FileModeWarning, UnrewindableBodyError)
NETRC_FILES = ('.netrc', '_netrc')
DEFAULT_CA_BUNDLE_PATH = certs.where()
DEFAULT_PORTS = {'http': 80, 'https': 443}
if sys.platform == 'win32':
# provide a proxy_bypass version on Windows without DNS lookups
def proxy_bypass_registry(host):
try:
if is_py3:
import winreg
else:
import _winreg as winreg
except ImportError:
return False
try:
internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
# ProxyEnable could be REG_SZ or REG_DWORD, normalizing it
proxyEnable = int(winreg.QueryValueEx(internetSettings,
'ProxyEnable')[0])
# ProxyOverride is almost always a string
proxyOverride = winreg.QueryValueEx(internetSettings,
'ProxyOverride')[0]
except OSError:
return False
if not proxyEnable or not proxyOverride:
return False
# make a check value list from the registry entry: replace the
# '<local>' string by the localhost entry and the corresponding
# canonical entry.
proxyOverride = proxyOverride.split(';')
# now check if we match one of the registry values.
for test in proxyOverride:
if test == '<local>':
if '.' not in host:
return True
test = test.replace(".", r"\.") # mask dots
test = test.replace("*", r".*") # change glob sequence
test = test.replace("?", r".") # change glob char
if re.match(test, host, re.I):
return True
return False
def proxy_bypass(host): # noqa
"""Return True, if the host should be bypassed.
Checks proxy settings gathered from the environment, if specified,
or the registry.
"""
if getproxies_environment():
return proxy_bypass_environment(host)
else:
return proxy_bypass_registry(host)
def dict_to_sequence(d):
"""Returns an internal sequence dictionary update."""
if hasattr(d, 'items'):
d = d.items()
return d
def super_len(o):
total_length = None
current_position = 0
if hasattr(o, '__len__'):
total_length = len(o)
elif hasattr(o, 'len'):
total_length = o.len
elif hasattr(o, 'fileno'):
try:
fileno = o.fileno()
except io.UnsupportedOperation:
pass
else:
total_length = os.fstat(fileno).st_size
# Having used fstat to determine the file length, we need to
# confirm that this file was opened up in binary mode.
if 'b' not in o.mode:
warnings.warn((
"Requests has determined the content-length for this "
"request using the binary size of the file: however, the "
"file has been opened in text mode (i.e. without the 'b' "
"flag in the mode). This may lead to an incorrect "
"content-length. In Requests 3.0, support will be removed "
"for files in text mode."),
FileModeWarning
)
if hasattr(o, 'tell'):
try:
current_position = o.tell()
except (OSError, IOError):
# This can happen in some weird situations, such as when the file
# is actually a special file descriptor like stdin. In this
# instance, we don't know what the length is, so set it to zero and
# let requests chunk it instead.
if total_length is not None:
current_position = total_length
else:
if hasattr(o, 'seek') and total_length is None:
# StringIO and BytesIO have seek but no useable fileno
try:
# seek to end of file
o.seek(0, 2)
total_length = o.tell()
# seek back to current position to support
# partially read file-like objects
o.seek(current_position or 0)
except (OSError, IOError):
total_length = 0
if total_length is None:
total_length = 0
return max(0, total_length - current_position)
def get_netrc_auth(url, raise_errors=False):
"""Returns the Requests tuple auth for a given url from netrc."""
try:
from netrc import netrc, NetrcParseError
netrc_path = None
for f in NETRC_FILES:
try:
loc = os.path.expanduser('~/{}'.format(f))
except KeyError:
# os.path.expanduser can fail when $HOME is undefined and
# getpwuid fails. See https://bugs.python.org/issue20164 &
# https://github.com/requests/requests/issues/1846
return
if os.path.exists(loc):
netrc_path = loc
break
# Abort early if there isn't one.
if netrc_path is None:
return
ri = urlparse(url)
host = ri.hostname
try:
_netrc = netrc(netrc_path).authenticators(host)
if _netrc:
# Return with login / password
login_i = (0 if _netrc[0] else 1)
return (_netrc[login_i], _netrc[2])
except (NetrcParseError, IOError):
# If there was a parsing error or a permissions issue reading the file,
# we'll just skip netrc auth unless explicitly asked to raise errors.
if raise_errors:
raise
# AppEngine hackiness.
except (ImportError, AttributeError):
pass
def guess_filename(obj):
"""Tries to guess the filename of the given object."""
name = getattr(obj, 'name', None)
if (name and isinstance(name, basestring) and name[0] != '<' and
name[-1] != '>'):
return os.path.basename(name)
def extract_zipped_paths(path):
"""Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
"""
if os.path.exists(path):
# this is already a valid path, no need to do anything further
return path
# find the first valid part of the provided path and treat that as a zip archive
# assume the rest of the path is the name of a member in the archive
archive, member = os.path.split(path)
while archive and not os.path.exists(archive):
archive, prefix = os.path.split(archive)
member = '/'.join([prefix, member])
if not zipfile.is_zipfile(archive):
return path
zip_file = zipfile.ZipFile(archive)
if member not in zip_file.namelist():
return path
# we have a valid zip archive and a valid member of that archive
tmp = tempfile.gettempdir()
extracted_path = os.path.join(tmp, *member.split('/'))
if not os.path.exists(extracted_path):
extracted_path = zip_file.extract(member, path=tmp)
return extracted_path
def from_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: need more than 1 value to unpack
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError('cannot encode objects that are not 2-tuples')
return OrderedDict(value)
def to_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. If it can be, return a list of tuples, e.g.,
::
>>> to_key_val_list([('key', 'val')])
[('key', 'val')]
>>> to_key_val_list({'key': 'val'})
[('key', 'val')]
>>> to_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples.
:rtype: list
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError('cannot encode objects that are not 2-tuples')
if isinstance(value, Mapping):
value = value.items()
return list(value)
# From mitsuhiko/werkzeug (used with permission).
def parse_list_header(value):
"""Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
"""
result = []
for item in _parse_list_header(value):
if item[:1] == item[-1:] == '"':
item = unquote_header_value(item[1:-1])
result.append(item)
return result
# From mitsuhiko/werkzeug (used with permission).
def parse_dict_header(value):
"""Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
"""
result = {}
for item in _parse_list_header(value):
if '=' not in item:
result[item] = None
continue
name, value = item.split('=', 1)
if value[:1] == value[-1:] == '"':
value = unquote_header_value(value[1:-1])
result[name] = value
return result
# From mitsuhiko/werkzeug (used with permission).
def unquote_header_value(value, is_filename=False):
r"""Unquotes a header value. (Reversal of :func:`quote_header_value`).
This does not use the real unquoting but what browsers are actually
using for quoting.
:param value: the header value to unquote.
:rtype: str
"""
if value and value[0] == value[-1] == '"':
# this is not the real unquoting, but fixing this so that the
# RFC is met will result in bugs with internet explorer and
# probably some other browsers as well. IE for example is
# uploading files with "C:\foo\bar.txt" as filename
value = value[1:-1]
# if this is a filename and the starting characters look like
# a UNC path, then just return the value without quotes. Using the
# replace sequence below on a UNC path has the effect of turning
# the leading double slash into a single slash and then
# _fix_ie_filename() doesn't work correctly. See #458.
if not is_filename or value[:2] != '\\\\':
return value.replace('\\\\', '\\').replace('\\"', '"')
return value
def dict_from_cookiejar(cj):
"""Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
"""
cookie_dict = {}
for cookie in cj:
cookie_dict[cookie.name] = cookie.value
return cookie_dict
def add_dict_to_cookiejar(cj, cookie_dict):
"""Returns a CookieJar from a key/value dictionary.
:param cj: CookieJar to insert cookies into.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:rtype: CookieJar
"""
return cookiejar_from_dict(cookie_dict, cj)
def get_encodings_from_content(content):
"""Returns encodings from given content string.
:param content: bytestring to extract encodings from.
"""
warnings.warn((
'In requests 3.0, get_encodings_from_content will be removed. For '
'more information, please see the discussion on issue #2266. (This'
' warning should only appear once.)'),
DeprecationWarning)
charset_re = re.compile(r'<meta.*?charset=["\']*(.+?)["\'>]', flags=re.I)
pragma_re = re.compile(r'<meta.*?content=["\']*;?charset=(.+?)["\'>]', flags=re.I)
xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]')
return (charset_re.findall(content) +
pragma_re.findall(content) +
xml_re.findall(content))
def _parse_content_type_header(header):
"""Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
"""
tokens = header.split(';')
content_type, params = tokens[0].strip(), tokens[1:]
params_dict = {}
items_to_strip = "\"' "
for param in params:
param = param.strip()
if param:
key, value = param, True
index_of_equals = param.find("=")
if index_of_equals != -1:
key = param[:index_of_equals].strip(items_to_strip)
value = param[index_of_equals + 1:].strip(items_to_strip)
params_dict[key.lower()] = value
return content_type, params_dict
def get_encoding_from_headers(headers):
"""Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
"""
content_type = headers.get('content-type')
if not content_type:
return None
content_type, params = _parse_content_type_header(content_type)
if 'charset' in params:
return params['charset'].strip("'\"")
if 'text' in content_type:
return 'ISO-8859-1'
def stream_decode_response_unicode(iterator, r):
"""Stream decodes a iterator."""
if r.encoding is None:
for item in iterator:
yield item
return
decoder = codecs.getincrementaldecoder(r.encoding)(errors='replace')
for chunk in iterator:
rv = decoder.decode(chunk)
if rv:
yield rv
rv = decoder.decode(b'', final=True)
if rv:
yield rv
def iter_slices(string, slice_length):
"""Iterate over slices of a string."""
pos = 0
if slice_length is None or slice_length <= 0:
slice_length = len(string)
while pos < len(string):
yield string[pos:pos + slice_length]
pos += slice_length
def get_unicode_from_response(r):
"""Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
"""
warnings.warn((
'In requests 3.0, get_unicode_from_response will be removed. For '
'more information, please see the discussion on issue #2266. (This'
' warning should only appear once.)'),
DeprecationWarning)
tried_encodings = []
# Try charset from content-type
encoding = get_encoding_from_headers(r.headers)
if encoding:
try:
return str(r.content, encoding)
except UnicodeError:
tried_encodings.append(encoding)
# Fall back:
try:
return str(r.content, encoding, errors='replace')
except TypeError:
return r.content
# The unreserved URI characters (RFC 3986)
UNRESERVED_SET = frozenset(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~")
def unquote_unreserved(uri):
"""Un-escape any percent-escape sequences in a URI that are unreserved
characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
:rtype: str
"""
parts = uri.split('%')
for i in range(1, len(parts)):
h = parts[i][0:2]
if len(h) == 2 and h.isalnum():
try:
c = chr(int(h, 16))
except ValueError:
raise InvalidURL("Invalid percent-escape sequence: '%s'" % h)
if c in UNRESERVED_SET:
parts[i] = c + parts[i][2:]
else:
parts[i] = '%' + parts[i]
else:
parts[i] = '%' + parts[i]
return ''.join(parts)
def requote_uri(uri):
"""Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
"""
safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
safe_without_percent = "!#$&'()*+,/:;=?@[]~"
try:
# Unquote only the unreserved characters
# Then quote only illegal characters (do not quote reserved,
# unreserved, or '%')
return quote(unquote_unreserved(uri), safe=safe_with_percent)
except InvalidURL:
# We couldn't unquote the given URI, so let's try quoting it, but
# there may be unquoted '%'s in the URI. We need to make sure they're
# properly quoted so they do not cause issues elsewhere.
return quote(uri, safe=safe_without_percent)
def address_in_network(ip, net):
"""This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
"""
ipaddr = struct.unpack('=L', socket.inet_aton(ip))[0]
netaddr, bits = net.split('/')
netmask = struct.unpack('=L', socket.inet_aton(dotted_netmask(int(bits))))[0]
network = struct.unpack('=L', socket.inet_aton(netaddr))[0] & netmask
return (ipaddr & netmask) == (network & netmask)
def dotted_netmask(mask):
"""Converts mask from /xx format to xxx.xxx.xxx.xxx
Example: if mask is 24 function returns 255.255.255.0
:rtype: str
"""
bits = 0xffffffff ^ (1 << 32 - mask) - 1
return socket.inet_ntoa(struct.pack('>I', bits))
def is_ipv4_address(string_ip):
"""
:rtype: bool
"""
try:
socket.inet_aton(string_ip)
except socket.error:
return False
return True
def is_valid_cidr(string_network):
"""
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
"""
if string_network.count('/') == 1:
try:
mask = int(string_network.split('/')[1])
except ValueError:
return False
if mask < 1 or mask > 32:
return False
try:
socket.inet_aton(string_network.split('/')[0])
except socket.error:
return False
else:
return False
return True
@contextlib.contextmanager
def set_environ(env_name, value):
"""Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothing"""
value_changed = value is not None
if value_changed:
old_value = os.environ.get(env_name)
os.environ[env_name] = value
try:
yield
finally:
if value_changed:
if old_value is None:
del os.environ[env_name]
else:
os.environ[env_name] = old_value
def should_bypass_proxies(url, no_proxy):
"""
Returns whether we should bypass proxies or not.
:rtype: bool
"""
# Prioritize lowercase environment variables over uppercase
# to keep a consistent behaviour with other http projects (curl, wget).
get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())
# First check whether no_proxy is defined. If it is, check that the URL
# we're getting isn't in the no_proxy list.
no_proxy_arg = no_proxy
if no_proxy is None:
no_proxy = get_proxy('no_proxy')
parsed = urlparse(url)
if parsed.hostname is None:
# URLs don't always have hostnames, e.g. file:/// urls.
return True
if no_proxy:
# We need to check whether we match here. We need to see if we match
# the end of the hostname, both with and without the port.
no_proxy = (
host for host in no_proxy.replace(' ', '').split(',') if host
)
if is_ipv4_address(parsed.hostname):
for proxy_ip in no_proxy:
if is_valid_cidr(proxy_ip):
if address_in_network(parsed.hostname, proxy_ip):
return True
elif parsed.hostname == proxy_ip:
# If no_proxy ip was defined in plain IP notation instead of cidr notation &
# matches the IP of the index
return True
else:
host_with_port = parsed.hostname
if parsed.port:
host_with_port += ':{}'.format(parsed.port)
for host in no_proxy:
if parsed.hostname.endswith(host) or host_with_port.endswith(host):
# The URL does match something in no_proxy, so we don't want
# to apply the proxies on this URL.
return True
with set_environ('no_proxy', no_proxy_arg):
# parsed.hostname can be `None` in cases such as a file URI.
try:
bypass = proxy_bypass(parsed.hostname)
except (TypeError, socket.gaierror):
bypass = False
if bypass:
return True
return False
def get_environ_proxies(url, no_proxy=None):
"""
Return a dict of environment proxies.
:rtype: dict
"""
if should_bypass_proxies(url, no_proxy=no_proxy):
return {}
else:
return getproxies()
def select_proxy(url, proxies):
"""Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
"""
proxies = proxies or {}
urlparts = urlparse(url)
if urlparts.hostname is None:
return proxies.get(urlparts.scheme, proxies.get('all'))
proxy_keys = [
urlparts.scheme + '://' + urlparts.hostname,
urlparts.scheme,
'all://' + urlparts.hostname,
'all',
]
proxy = None
for proxy_key in proxy_keys:
if proxy_key in proxies:
proxy = proxies[proxy_key]
break
return proxy
def default_user_agent(name="python-requests"):
"""
Return a string representing the default user agent.
:rtype: str
"""
return '%s/%s' % (name, __version__)
def default_headers():
"""
:rtype: requests.structures.CaseInsensitiveDict
"""
return CaseInsensitiveDict({
'User-Agent': default_user_agent(),
'Accept-Encoding': ', '.join(('gzip', 'deflate')),
'Accept': '*/*',
'Connection': 'keep-alive',
})
def parse_header_links(value):
"""Return a list of parsed link headers proxies.
i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"
:rtype: list
"""
links = []
replace_chars = ' \'"'
value = value.strip(replace_chars)
if not value:
return links
for val in re.split(', *<', value):
try:
url, params = val.split(';', 1)
except ValueError:
url, params = val, ''
link = {'url': url.strip('<> \'"')}
for param in params.split(';'):
try:
key, value = param.split('=')
except ValueError:
break
link[key.strip(replace_chars)] = value.strip(replace_chars)
links.append(link)
return links
# Null bytes; no need to recreate these on each call to guess_json_utf
_null = '\x00'.encode('ascii') # encoding to ASCII for Python 3
_null2 = _null * 2
_null3 = _null * 3
def guess_json_utf(data):
"""
:rtype: str
"""
# JSON always starts with two ASCII characters, so detection is as
# easy as counting the nulls and from their location and count
# determine the encoding. Also detect a BOM, if present.
sample = data[:4]
if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
return 'utf-32' # BOM included
if sample[:3] == codecs.BOM_UTF8:
return 'utf-8-sig' # BOM included, MS style (discouraged)
if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
return 'utf-16' # BOM included
nullcount = sample.count(_null)
if nullcount == 0:
return 'utf-8'
if nullcount == 2:
if sample[::2] == _null2: # 1st and 3rd are null
return 'utf-16-be'
if sample[1::2] == _null2: # 2nd and 4th are null
return 'utf-16-le'
# Did not detect 2 valid UTF-16 ascii-range characters
if nullcount == 3:
if sample[:3] == _null3:
return 'utf-32-be'
if sample[1:] == _null3:
return 'utf-32-le'
# Did not detect a valid UTF-32 ascii-range character
return None
def prepend_scheme_if_needed(url, new_scheme):
"""Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url, new_scheme)
# urlparse is a finicky beast, and sometimes decides that there isn't a
# netloc present. Assume that it's being over-cautious, and switch netloc
# and path if urlparse decided there was no netloc.
if not netloc:
netloc, path = path, netloc
return urlunparse((scheme, netloc, path, params, query, fragment))
def get_auth_from_url(url):
"""Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
"""
parsed = urlparse(url)
try:
auth = (unquote(parsed.username), unquote(parsed.password))
except (AttributeError, TypeError):
auth = ('', '')
return auth
# Moved outside of function to avoid recompile every call
_CLEAN_HEADER_REGEX_BYTE = re.compile(b'^\\S[^\\r\\n]*$|^$')
_CLEAN_HEADER_REGEX_STR = re.compile(r'^\S[^\r\n]*$|^$')
def check_header_validity(header):
"""Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
"""
name, value = header
if isinstance(value, bytes):
pat = _CLEAN_HEADER_REGEX_BYTE
else:
pat = _CLEAN_HEADER_REGEX_STR
try:
if not pat.match(value):
raise InvalidHeader("Invalid return character or leading space in header: %s" % name)
except TypeError:
raise InvalidHeader("Value for header {%s: %s} must be of type str or "
"bytes, not %s" % (name, value, type(value)))
def urldefragauth(url):
"""
Given a url remove the fragment and the authentication part.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url)
# see func:`prepend_scheme_if_needed`
if not netloc:
netloc, path = path, netloc
netloc = netloc.rsplit('@', 1)[-1]
return urlunparse((scheme, netloc, path, params, query, ''))
def rewind_body(prepared_request):
"""Move file pointer back to its recorded starting position
so it can be read again on redirect.
"""
body_seek = getattr(prepared_request.body, 'seek', None)
if body_seek is not None and isinstance(prepared_request._body_position, integer_types):
try:
body_seek(prepared_request._body_position)
except (IOError, OSError):
raise UnrewindableBodyError("An error occurred when rewinding request "
"body for redirect.")
else:
raise UnrewindableBodyError("Unable to rewind request body for redirect.")
hooks.py 0000644 00000001365 15173103335 0006247 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.hooks
~~~~~~~~~~~~~~
This module provides the capabilities for the Requests hooks system.
Available hooks:
``response``:
The response generated from a Request.
"""
HOOKS = ['response']
def default_hooks():
return {event: [] for event in HOOKS}
# TODO: response is the only one
def dispatch_hook(key, hooks, hook_data, **kwargs):
"""Dispatches a hook dictionary on a given piece of data."""
hooks = hooks or {}
hooks = hooks.get(key)
if hooks:
if hasattr(hooks, '__call__'):
hooks = [hooks]
for hook in hooks:
_hook_data = hook(hook_data, **kwargs)
if _hook_data is not None:
hook_data = _hook_data
return hook_data
status_codes.py 0000644 00000010041 15173103335 0007613 0 ustar 00 # -*- coding: utf-8 -*-
r"""
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
"""
from .structures import LookupDict
_codes = {
# Informational.
100: ('continue',),
101: ('switching_protocols',),
102: ('processing',),
103: ('checkpoint',),
122: ('uri_too_long', 'request_uri_too_long'),
200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),
201: ('created',),
202: ('accepted',),
203: ('non_authoritative_info', 'non_authoritative_information'),
204: ('no_content',),
205: ('reset_content', 'reset'),
206: ('partial_content', 'partial'),
207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
208: ('already_reported',),
226: ('im_used',),
# Redirection.
300: ('multiple_choices',),
301: ('moved_permanently', 'moved', '\\o-'),
302: ('found',),
303: ('see_other', 'other'),
304: ('not_modified',),
305: ('use_proxy',),
306: ('switch_proxy',),
307: ('temporary_redirect', 'temporary_moved', 'temporary'),
308: ('permanent_redirect',
'resume_incomplete', 'resume',), # These 2 to be removed in 3.0
# Client Error.
400: ('bad_request', 'bad'),
401: ('unauthorized',),
402: ('payment_required', 'payment'),
403: ('forbidden',),
404: ('not_found', '-o-'),
405: ('method_not_allowed', 'not_allowed'),
406: ('not_acceptable',),
407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
408: ('request_timeout', 'timeout'),
409: ('conflict',),
410: ('gone',),
411: ('length_required',),
412: ('precondition_failed', 'precondition'),
413: ('request_entity_too_large',),
414: ('request_uri_too_large',),
415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
417: ('expectation_failed',),
418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
421: ('misdirected_request',),
422: ('unprocessable_entity', 'unprocessable'),
423: ('locked',),
424: ('failed_dependency', 'dependency'),
425: ('unordered_collection', 'unordered'),
426: ('upgrade_required', 'upgrade'),
428: ('precondition_required', 'precondition'),
429: ('too_many_requests', 'too_many'),
431: ('header_fields_too_large', 'fields_too_large'),
444: ('no_response', 'none'),
449: ('retry_with', 'retry'),
450: ('blocked_by_windows_parental_controls', 'parental_controls'),
451: ('unavailable_for_legal_reasons', 'legal_reasons'),
499: ('client_closed_request',),
# Server Error.
500: ('internal_server_error', 'server_error', '/o\\', '✗'),
501: ('not_implemented',),
502: ('bad_gateway',),
503: ('service_unavailable', 'unavailable'),
504: ('gateway_timeout',),
505: ('http_version_not_supported', 'http_version'),
506: ('variant_also_negotiates',),
507: ('insufficient_storage',),
509: ('bandwidth_limit_exceeded', 'bandwidth'),
510: ('not_extended',),
511: ('network_authentication_required', 'network_auth', 'network_authentication'),
}
codes = LookupDict(name='status_codes')
def _init():
for code, titles in _codes.items():
for title in titles:
setattr(codes, title, code)
if not title.startswith(('\\', '/')):
setattr(codes, title.upper(), code)
def doc(code):
names = ', '.join('``%s``' % n for n in _codes[code])
return '* %d: %s' % (code, names)
global __doc__
__doc__ = (__doc__ + '\n' +
'\n'.join(doc(code) for code in sorted(_codes))
if __doc__ is not None else None)
_init()
adapters.py 0000644 00000070467 15173103335 0006740 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.adapters
~~~~~~~~~~~~~~~~~
This module contains the transport adapters that Requests uses to define
and maintain connections.
"""
import os.path
import socket
import typing
from urllib3.poolmanager import PoolManager, proxy_from_url
from urllib3.response import HTTPResponse
from urllib3.util import parse_url
from urllib3.util import Timeout as TimeoutSauce
from urllib3.util.retry import Retry
from urllib3.util.ssl_ import create_urllib3_context
from urllib3.exceptions import ClosedPoolError
from urllib3.exceptions import ConnectTimeoutError
from urllib3.exceptions import HTTPError as _HTTPError
from urllib3.exceptions import MaxRetryError
from urllib3.exceptions import NewConnectionError
from urllib3.exceptions import ProxyError as _ProxyError
from urllib3.exceptions import ProtocolError
from urllib3.exceptions import ReadTimeoutError
from urllib3.exceptions import SSLError as _SSLError
from urllib3.exceptions import ResponseError
from urllib3.exceptions import LocationValueError
from .models import Response
from .compat import urlparse, basestring
from .utils import (DEFAULT_CA_BUNDLE_PATH, extract_zipped_paths,
get_encoding_from_headers, prepend_scheme_if_needed,
get_auth_from_url, urldefragauth, select_proxy)
from .structures import CaseInsensitiveDict
from .cookies import extract_cookies_to_jar
from .exceptions import (ConnectionError, ConnectTimeout, ReadTimeout, SSLError,
ProxyError, RetryError, InvalidSchema, InvalidProxyURL,
InvalidURL)
from .auth import _basic_auth_str
try:
from urllib3.contrib.socks import SOCKSProxyManager
except ImportError:
def SOCKSProxyManager(*args, **kwargs):
raise InvalidSchema("Missing dependencies for SOCKS support.")
DEFAULT_POOLBLOCK = False
DEFAULT_POOLSIZE = 10
DEFAULT_RETRIES = 0
DEFAULT_POOL_TIMEOUT = None
try:
import ssl # noqa: F401
_preloaded_ssl_context = create_urllib3_context()
_preloaded_ssl_context.load_verify_locations(
extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
)
except ImportError:
# Bypass default SSLContext creation when Python
# interpreter isn't built with the ssl module.
_preloaded_ssl_context = None
def _should_use_default_context(
verify: "bool | str | None",
client_cert: "typing.Tuple[str, str] | str | None",
poolmanager_kwargs: typing.Dict[str, typing.Any],
) -> bool:
# Determine if we have and should use our default SSLContext
# to optimize performance on standard requests.
has_poolmanager_ssl_context = poolmanager_kwargs.get("ssl_context")
should_use_default_ssl_context = (
verify is True
and _preloaded_ssl_context is not None
and not has_poolmanager_ssl_context
and client_cert is None
)
return should_use_default_ssl_context
def _urllib3_request_context(
request: "PreparedRequest",
verify: "bool | str | None",
client_cert: "typing.Tuple[str, str] | str | None",
poolmanager: "PoolManager",
) -> "(typing.Dict[str, typing.Any], typing.Dict[str, typing.Any])":
host_params = {}
pool_kwargs = {}
parsed_request_url = urlparse(request.url)
scheme = parsed_request_url.scheme.lower()
port = parsed_request_url.port
poolmanager_kwargs = getattr(poolmanager, "connection_pool_kw", {})
cert_reqs = "CERT_REQUIRED"
cert_loc = None
if verify is False:
cert_reqs = "CERT_NONE"
elif _should_use_default_context(verify, client_cert, poolmanager_kwargs):
pool_kwargs["ssl_context"] = _preloaded_ssl_context
elif verify is True:
# Set default ca cert location if none provided
cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
elif isinstance(verify, str):
cert_loc = verify
if cert_loc is not None:
if not os.path.isdir(cert_loc):
pool_kwargs["ca_certs"] = cert_loc
else:
pool_kwargs["ca_cert_dir"] = cert_loc
pool_kwargs["cert_reqs"] = cert_reqs
if client_cert is not None:
if isinstance(client_cert, tuple) and len(client_cert) == 2:
pool_kwargs["cert_file"] = client_cert[0]
pool_kwargs["key_file"] = client_cert[1]
else:
# According to our docs, we allow users to specify just the client
# cert path
pool_kwargs["cert_file"] = client_cert
host_params = {
"scheme": scheme,
"host": parsed_request_url.hostname,
"port": port,
}
return host_params, pool_kwargs
class BaseAdapter(object):
"""The Base Transport Adapter"""
def __init__(self):
super(BaseAdapter, self).__init__()
def send(self, request, stream=False, timeout=None, verify=True,
cert=None, proxies=None):
"""Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
"""
raise NotImplementedError
def close(self):
"""Cleans up adapter specific items."""
raise NotImplementedError
class HTTPAdapter(BaseAdapter):
"""The built-in HTTP Adapter for urllib3.
Provides a general-case interface for Requests sessions to contact HTTP and
HTTPS urls by implementing the Transport Adapter interface. This class will
usually be created by the :class:`Session <Session>` class under the
covers.
:param pool_connections: The number of urllib3 connection pools to cache.
:param pool_maxsize: The maximum number of connections to save in the pool.
:param max_retries: The maximum number of retries each connection
should attempt. Note, this applies only to failed DNS lookups, socket
connections and connection timeouts, never to requests where data has
made it to the server. By default, Requests does not retry failed
connections. If you need granular control over the conditions under
which we retry a request, import urllib3's ``Retry`` class and pass
that instead.
:param pool_block: Whether the connection pool should block for connections.
Usage::
>>> import requests
>>> s = requests.Session()
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
>>> s.mount('http://', a)
"""
__attrs__ = ['max_retries', 'config', '_pool_connections', '_pool_maxsize',
'_pool_block']
def __init__(self, pool_connections=DEFAULT_POOLSIZE,
pool_maxsize=DEFAULT_POOLSIZE, max_retries=DEFAULT_RETRIES,
pool_block=DEFAULT_POOLBLOCK):
if max_retries == DEFAULT_RETRIES:
self.max_retries = Retry(0, read=False)
else:
self.max_retries = Retry.from_int(max_retries)
self.config = {}
self.proxy_manager = {}
super(HTTPAdapter, self).__init__()
self._pool_connections = pool_connections
self._pool_maxsize = pool_maxsize
self._pool_block = pool_block
self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
def __getstate__(self):
return {attr: getattr(self, attr, None) for attr in self.__attrs__}
def __setstate__(self, state):
# Can't handle by adding 'proxy_manager' to self.__attrs__ because
# self.poolmanager uses a lambda function, which isn't pickleable.
self.proxy_manager = {}
self.config = {}
for attr, value in state.items():
setattr(self, attr, value)
self.init_poolmanager(self._pool_connections, self._pool_maxsize,
block=self._pool_block)
def init_poolmanager(self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs):
"""Initializes a urllib3 PoolManager.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param connections: The number of urllib3 connection pools to cache.
:param maxsize: The maximum number of connections to save in the pool.
:param block: Block when no free connections are available.
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
"""
# save these values for pickling
self._pool_connections = connections
self._pool_maxsize = maxsize
self._pool_block = block
self.poolmanager = PoolManager(num_pools=connections, maxsize=maxsize,
block=block, strict=True, **pool_kwargs)
def proxy_manager_for(self, proxy, **proxy_kwargs):
"""Return urllib3 ProxyManager for the given proxy.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The proxy to return a urllib3 ProxyManager for.
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
:returns: ProxyManager
:rtype: urllib3.ProxyManager
"""
if proxy in self.proxy_manager:
manager = self.proxy_manager[proxy]
elif proxy.lower().startswith('socks'):
username, password = get_auth_from_url(proxy)
manager = self.proxy_manager[proxy] = SOCKSProxyManager(
proxy,
username=username,
password=password,
num_pools=self._pool_connections,
maxsize=self._pool_maxsize,
block=self._pool_block,
**proxy_kwargs
)
else:
proxy_headers = self.proxy_headers(proxy)
manager = self.proxy_manager[proxy] = proxy_from_url(
proxy,
proxy_headers=proxy_headers,
num_pools=self._pool_connections,
maxsize=self._pool_maxsize,
block=self._pool_block,
**proxy_kwargs)
return manager
def cert_verify(self, conn, url, verify, cert):
"""Verify a SSL certificate. This method should not be called from user
code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param conn: The urllib3 connection object associated with the cert.
:param url: The requested URL.
:param verify: 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
:param cert: The SSL certificate to verify.
"""
if url.lower().startswith('https') and verify:
conn.cert_reqs = "CERT_REQUIRED"
# Only load the CA certificates if `verify` is a
# string indicating the CA bundle to use.
if verify is not True:
# `verify` must be a str with a path then
cert_loc = verify
if not os.path.exists(cert_loc):
raise OSError(
f"Could not find a suitable TLS CA certificate bundle, "
f"invalid path: {cert_loc}"
)
if not os.path.isdir(cert_loc):
conn.ca_certs = cert_loc
else:
conn.ca_cert_dir = cert_loc
else:
conn.cert_reqs = 'CERT_NONE'
conn.ca_certs = None
conn.ca_cert_dir = None
if cert:
if not isinstance(cert, basestring):
conn.cert_file = cert[0]
conn.key_file = cert[1]
else:
conn.cert_file = cert
conn.key_file = None
if conn.cert_file and not os.path.exists(conn.cert_file):
raise IOError("Could not find the TLS certificate file, "
"invalid path: {}".format(conn.cert_file))
if conn.key_file and not os.path.exists(conn.key_file):
raise IOError("Could not find the TLS key file, "
"invalid path: {}".format(conn.key_file))
def build_response(self, req, resp):
"""Builds a :class:`Response <requests.Response>` object from a urllib3
response. This should not be called from user code, and is only exposed
for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
:param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
:param resp: The urllib3 response object.
:rtype: requests.Response
"""
response = Response()
# Fallback to None if there's no status_code, for whatever reason.
response.status_code = getattr(resp, 'status', None)
# Make headers case-insensitive.
response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {}))
# Set encoding.
response.encoding = get_encoding_from_headers(response.headers)
response.raw = resp
response.reason = response.raw.reason
if isinstance(req.url, bytes):
response.url = req.url.decode('utf-8')
else:
response.url = req.url
# Add new cookies from the server.
extract_cookies_to_jar(response.cookies, req, resp)
# Give the Response some context.
response.request = req
response.connection = self
return response
def build_connection_pool_key_attributes(self, request, verify, cert=None):
"""Build the PoolKey attributes used by urllib3 to return a connection.
This looks at the PreparedRequest, the user-specified verify value,
and the value of the cert parameter to determine what PoolKey values
to use to select a connection from a given urllib3 Connection Pool.
The SSL related pool key arguments are not consistently set. As of
this writing, use the following to determine what keys may be in that
dictionary:
* If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the
default Requests SSL Context
* If ``verify`` is ``False``, ``"ssl_context"`` will not be set but
``"cert_reqs"`` will be set
* If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
``"ca_certs"`` will be set if the string is not a directory recognized
by :py:func:`os.path.isdir`, otherwise ``"ca_certs_dir"`` will be
set.
* If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
``"cert"`` is a tuple with a second item, ``"key_file"`` will also
be present
To override these settings, one may subclass this class, call this
method and use the above logic to change parameters as desired. For
example, if one wishes to use a custom :py:class:`ssl.SSLContext` one
must both set ``"ssl_context"`` and based on what else they require,
alter the other keys to ensure the desired behaviour.
:param request:
The PreparedReqest being sent over the connection.
:type request:
:class:`~requests.models.PreparedRequest`
:param verify:
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.
:param cert:
(optional) Any user-provided SSL certificate for client
authentication (a.k.a., mTLS). This may be a string (i.e., just
the path to a file which holds both certificate and key) or a
tuple of length 2 with the certificate file path and key file
path.
:returns:
A tuple of two dictionaries. The first is the "host parameters"
portion of the Pool Key including scheme, hostname, and port. The
second is a dictionary of SSLContext related parameters.
"""
return _urllib3_request_context(request, verify, cert, self.poolmanager)
def get_connection_with_tls_context(self, request, verify, proxies=None, cert=None):
"""Returns a urllib3 connection for the given request and TLS settings.
This should not be called from user code, and is only exposed for use
when subclassing the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request:
The :class:`PreparedRequest <PreparedRequest>` object to be sent
over the connection.
:param verify:
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.
:param proxies:
(optional) The proxies dictionary to apply to the request.
:param cert:
(optional) Any user-provided SSL certificate to be used for client
authentication (a.k.a., mTLS).
:rtype:
urllib3.ConnectionPool
"""
proxy = select_proxy(request.url, proxies)
try:
host_params, pool_kwargs = self.build_connection_pool_key_attributes(
request,
verify,
cert,
)
except ValueError as e:
raise InvalidURL(e, request=request)
if proxy:
proxy = prepend_scheme_if_needed(proxy, "http")
proxy_url = parse_url(proxy)
if not proxy_url.host:
raise InvalidProxyURL(
"Please check proxy URL. It is malformed "
"and could be missing the host."
)
proxy_manager = self.proxy_manager_for(proxy)
conn = proxy_manager.connection_from_host(
**host_params, pool_kwargs=pool_kwargs
)
else:
# Only scheme should be lower case
conn = self.poolmanager.connection_from_host(
**host_params, pool_kwargs=pool_kwargs
)
return conn
def get_connection(self, url, proxies=None):
"""DEPRECATED: Users should move to `get_connection_with_tls_context`
for all subclasses of HTTPAdapter using Requests>=2.32.2.
Returns a urllib3 connection for the given URL. This should not be
called from user code, and is only exposed for use when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param url: The URL to connect to.
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
:rtype: urllib3.ConnectionPool
"""
proxy = select_proxy(url, proxies)
if proxy:
proxy = prepend_scheme_if_needed(proxy, 'http')
proxy_url = parse_url(proxy)
if not proxy_url.host:
raise InvalidProxyURL("Please check proxy URL. It is malformed"
" and could be missing the host.")
proxy_manager = self.proxy_manager_for(proxy)
conn = proxy_manager.connection_from_url(url)
else:
# Only scheme should be lower case
parsed = urlparse(url)
url = parsed.geturl()
conn = self.poolmanager.connection_from_url(url)
return conn
def close(self):
"""Disposes of any internal state.
Currently, this closes the PoolManager and any active ProxyManager,
which closes any pooled connections.
"""
self.poolmanager.clear()
for proxy in self.proxy_manager.values():
proxy.clear()
def request_url(self, request, proxies):
"""Obtain the url to use when making the final request.
If the message is being sent through a HTTP proxy, the full URL has to
be used. Otherwise, we should only use the path portion of the URL.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
:rtype: str
"""
proxy = select_proxy(request.url, proxies)
scheme = urlparse(request.url).scheme
is_proxied_http_request = (proxy and scheme != 'https')
using_socks_proxy = False
if proxy:
proxy_scheme = urlparse(proxy).scheme.lower()
using_socks_proxy = proxy_scheme.startswith('socks')
url = request.path_url
if is_proxied_http_request and not using_socks_proxy:
url = urldefragauth(request.url)
return url
def add_headers(self, request, **kwargs):
"""Add any headers needed by the connection. As of v2.0 this does
nothing by default, but is left for overriding by users that subclass
the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
:param kwargs: The keyword arguments from the call to send().
"""
pass
def proxy_headers(self, proxy):
"""Returns a dictionary of the headers to add to any request sent
through a proxy. This works with urllib3 magic to ensure that they are
correctly sent to the proxy, rather than in a tunnelled request if
CONNECT is being used.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
:param proxy: The url of the proxy being used for this request.
:rtype: dict
"""
headers = {}
username, password = get_auth_from_url(proxy)
if username:
headers['Proxy-Authorization'] = _basic_auth_str(username,
password)
return headers
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
"""Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
: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 or urllib3 Timeout object
: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
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
:rtype: requests.Response
"""
try:
conn = self.get_connection_with_tls_context(
request, verify, proxies=proxies, cert=cert
)
except LocationValueError as e:
raise InvalidURL(e, request=request)
self.cert_verify(conn, request.url, verify, cert)
url = self.request_url(request, proxies)
self.add_headers(request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies)
chunked = not (request.body is None or 'Content-Length' in request.headers)
if isinstance(timeout, tuple):
try:
connect, read = timeout
timeout = TimeoutSauce(connect=connect, read=read)
except ValueError as e:
# this may raise a string formatting error.
err = ("Invalid timeout {}. Pass a (connect, read) "
"timeout tuple, or a single float to set "
"both timeouts to the same value".format(timeout))
raise ValueError(err)
elif isinstance(timeout, TimeoutSauce):
pass
else:
timeout = TimeoutSauce(connect=timeout, read=timeout)
try:
if not chunked:
resp = conn.urlopen(
method=request.method,
url=url,
body=request.body,
headers=request.headers,
redirect=False,
assert_same_host=False,
preload_content=False,
decode_content=False,
retries=self.max_retries,
timeout=timeout
)
# Send the request.
else:
if hasattr(conn, 'proxy_pool'):
conn = conn.proxy_pool
low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)
try:
low_conn.putrequest(request.method,
url,
skip_accept_encoding=True)
for header, value in request.headers.items():
low_conn.putheader(header, value)
low_conn.endheaders()
for i in request.body:
low_conn.send(hex(len(i))[2:].encode('utf-8'))
low_conn.send(b'\r\n')
low_conn.send(i)
low_conn.send(b'\r\n')
low_conn.send(b'0\r\n\r\n')
# Receive the response from the server
try:
# For Python 2.7, use buffering of HTTP responses
r = low_conn.getresponse(buffering=True)
except TypeError:
# For compatibility with Python 3.3+
r = low_conn.getresponse()
resp = HTTPResponse.from_httplib(
r,
pool=conn,
connection=low_conn,
preload_content=False,
decode_content=False
)
except:
# If we hit any problems here, clean up the connection.
# Then, reraise so that we can handle the actual exception.
low_conn.close()
raise
except (ProtocolError, socket.error) as err:
raise ConnectionError(err, request=request)
except MaxRetryError as e:
if isinstance(e.reason, ConnectTimeoutError):
# TODO: Remove this in 3.0.0: see #2811
if not isinstance(e.reason, NewConnectionError):
raise ConnectTimeout(e, request=request)
if isinstance(e.reason, ResponseError):
raise RetryError(e, request=request)
if isinstance(e.reason, _ProxyError):
raise ProxyError(e, request=request)
if isinstance(e.reason, _SSLError):
# This branch is for urllib3 v1.22 and later.
raise SSLError(e, request=request)
raise ConnectionError(e, request=request)
except ClosedPoolError as e:
raise ConnectionError(e, request=request)
except _ProxyError as e:
raise ProxyError(e)
except (_SSLError, _HTTPError) as e:
if isinstance(e, _SSLError):
# This branch is for urllib3 versions earlier than v1.22
raise SSLError(e, request=request)
elif isinstance(e, ReadTimeoutError):
raise ReadTimeout(e, request=request)
else:
raise
return self.build_response(request, resp)
__init__.py 0000644 00000007030 15173103335 0006656 0 ustar 00 # -*- coding: utf-8 -*-
# __
# /__) _ _ _ _ _/ _
# / ( (- (/ (/ (- _) / _)
# /
"""
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings. Basic GET
usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> 'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('https://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key2": "value2",
"key1": "value1"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at <http://python-requests.org>.
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
"""
import urllib3
import chardet
import warnings
from .exceptions import RequestsDependencyWarning
def check_compatibility(urllib3_version, chardet_version):
urllib3_version = urllib3_version.split('.')
assert urllib3_version != ['dev'] # Verify urllib3 isn't installed from git.
# Sometimes, urllib3 only reports its version as 16.1.
if len(urllib3_version) == 2:
urllib3_version.append('0')
# Check urllib3 for compatibility.
major, minor, patch = urllib3_version # noqa: F811
major, minor, patch = int(major), int(minor), int(patch)
# urllib3 >= 1.21.1, <= 1.24
assert major == 1
assert minor >= 21
assert minor <= 24
# Check chardet for compatibility.
major, minor, patch = chardet_version.split('.')[:3]
major, minor, patch = int(major), int(minor), int(patch)
# chardet >= 3.0.2, < 3.1.0
assert major == 3
assert minor < 1
assert patch >= 2
def _check_cryptography(cryptography_version):
# cryptography < 1.3.4
try:
cryptography_version = list(map(int, cryptography_version.split('.')))
except ValueError:
return
if cryptography_version < [1, 3, 4]:
warning = 'Old version of cryptography ({}) may cause slowdown.'.format(cryptography_version)
warnings.warn(warning, RequestsDependencyWarning)
# Check imported dependencies for compatibility.
try:
check_compatibility(urllib3.__version__, chardet.__version__)
except (AssertionError, ValueError):
warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported "
"version!".format(urllib3.__version__, chardet.__version__),
RequestsDependencyWarning)
# urllib3's DependencyWarnings should be silenced.
from urllib3.exceptions import DependencyWarning
warnings.simplefilter('ignore', DependencyWarning)
from .__version__ import __title__, __description__, __url__, __version__
from .__version__ import __build__, __author__, __author_email__, __license__
from .__version__ import __copyright__, __cake__
from . import utils
from . import packages
from .models import Request, Response, PreparedRequest
from .api import request, get, head, post, patch, put, delete, options
from .sessions import session, Session
from .status_codes import codes
from .exceptions import (
RequestException, Timeout, URLRequired,
TooManyRedirects, HTTPError, ConnectionError,
FileModeWarning, ConnectTimeout, ReadTimeout
)
# Set default logging handler to avoid "No handler found" warnings.
import logging
from logging import NullHandler
logging.getLogger(__name__).addHandler(NullHandler())
# FileModeWarnings go off per the default.
warnings.simplefilter('default', FileModeWarning, append=True)
packages.py 0000644 00000001036 15173103335 0006675 0 ustar 00 import sys
# This code exists for backwards compatibility reasons.
# I don't like it either. Just look the other way. :)
for package in ('urllib3', 'idna', 'chardet'):
locals()[package] = __import__(package)
# This traversal is apparently necessary such that the identities are
# preserved (requests.packages.urllib3.* is urllib3.*)
for mod in list(sys.modules):
if mod == package or mod.startswith(package + '.'):
sys.modules['requests.packages.' + mod] = sys.modules[mod]
# Kinda cool, though, right?
auth.py 0000644 00000023736 15173103335 0006073 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.auth
~~~~~~~~~~~~~
This module contains the authentication handlers for Requests.
"""
import os
import re
import time
import hashlib
import threading
import warnings
from base64 import b64encode
from .compat import urlparse, str, basestring
from .cookies import extract_cookies_to_jar
from ._internal_utils import to_native_string
from .utils import parse_dict_header
CONTENT_TYPE_FORM_URLENCODED = 'application/x-www-form-urlencoded'
CONTENT_TYPE_MULTI_PART = 'multipart/form-data'
def _basic_auth_str(username, password):
"""Returns a Basic Auth string."""
# "I want us to put a big-ol' comment on top of it that
# says that this behaviour is dumb but we need to preserve
# it because people are relying on it."
# - Lukasa
#
# These are here solely to maintain backwards compatibility
# for things like ints. This will be removed in 3.0.0.
if not isinstance(username, basestring):
warnings.warn(
"Non-string usernames will no longer be supported in Requests "
"3.0.0. Please convert the object you've passed in ({!r}) to "
"a string or bytes object in the near future to avoid "
"problems.".format(username),
category=DeprecationWarning,
)
username = str(username)
if not isinstance(password, basestring):
warnings.warn(
"Non-string passwords will no longer be supported in Requests "
"3.0.0. Please convert the object you've passed in ({!r}) to "
"a string or bytes object in the near future to avoid "
"problems.".format(password),
category=DeprecationWarning,
)
password = str(password)
# -- End Removal --
if isinstance(username, str):
username = username.encode('latin1')
if isinstance(password, str):
password = password.encode('latin1')
authstr = 'Basic ' + to_native_string(
b64encode(b':'.join((username, password))).strip()
)
return authstr
class AuthBase(object):
"""Base class that all auth implementations derive from"""
def __call__(self, r):
raise NotImplementedError('Auth hooks must be callable.')
class HTTPBasicAuth(AuthBase):
"""Attaches HTTP Basic Authentication to the given Request object."""
def __init__(self, username, password):
self.username = username
self.password = password
def __eq__(self, other):
return all([
self.username == getattr(other, 'username', None),
self.password == getattr(other, 'password', None)
])
def __ne__(self, other):
return not self == other
def __call__(self, r):
r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
return r
class HTTPProxyAuth(HTTPBasicAuth):
"""Attaches HTTP Proxy Authentication to a given Request object."""
def __call__(self, r):
r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
return r
class HTTPDigestAuth(AuthBase):
"""Attaches HTTP Digest Authentication to the given Request object."""
def __init__(self, username, password):
self.username = username
self.password = password
# Keep state in per-thread local storage
self._thread_local = threading.local()
def init_per_thread_state(self):
# Ensure state is initialized just once per-thread
if not hasattr(self._thread_local, 'init'):
self._thread_local.init = True
self._thread_local.last_nonce = ''
self._thread_local.nonce_count = 0
self._thread_local.chal = {}
self._thread_local.pos = None
self._thread_local.num_401_calls = None
def build_digest_header(self, method, url):
"""
:rtype: str
"""
realm = self._thread_local.chal['realm']
nonce = self._thread_local.chal['nonce']
qop = self._thread_local.chal.get('qop')
algorithm = self._thread_local.chal.get('algorithm')
opaque = self._thread_local.chal.get('opaque')
hash_utf8 = None
if algorithm is None:
_algorithm = 'MD5'
else:
_algorithm = algorithm.upper()
# lambdas assume digest modules are imported at the top level
if _algorithm == 'MD5' or _algorithm == 'MD5-SESS':
def md5_utf8(x):
if isinstance(x, str):
x = x.encode('utf-8')
return hashlib.md5(x).hexdigest()
hash_utf8 = md5_utf8
elif _algorithm == 'SHA':
def sha_utf8(x):
if isinstance(x, str):
x = x.encode('utf-8')
return hashlib.sha1(x).hexdigest()
hash_utf8 = sha_utf8
elif _algorithm == 'SHA-256':
def sha256_utf8(x):
if isinstance(x, str):
x = x.encode('utf-8')
return hashlib.sha256(x).hexdigest()
hash_utf8 = sha256_utf8
elif _algorithm == 'SHA-512':
def sha512_utf8(x):
if isinstance(x, str):
x = x.encode('utf-8')
return hashlib.sha512(x).hexdigest()
hash_utf8 = sha512_utf8
KD = lambda s, d: hash_utf8("%s:%s" % (s, d))
if hash_utf8 is None:
return None
# XXX not implemented yet
entdig = None
p_parsed = urlparse(url)
#: path is request-uri defined in RFC 2616 which should not be empty
path = p_parsed.path or "/"
if p_parsed.query:
path += '?' + p_parsed.query
A1 = '%s:%s:%s' % (self.username, realm, self.password)
A2 = '%s:%s' % (method, path)
HA1 = hash_utf8(A1)
HA2 = hash_utf8(A2)
if nonce == self._thread_local.last_nonce:
self._thread_local.nonce_count += 1
else:
self._thread_local.nonce_count = 1
ncvalue = '%08x' % self._thread_local.nonce_count
s = str(self._thread_local.nonce_count).encode('utf-8')
s += nonce.encode('utf-8')
s += time.ctime().encode('utf-8')
s += os.urandom(8)
cnonce = (hashlib.sha1(s).hexdigest()[:16])
if _algorithm == 'MD5-SESS':
HA1 = hash_utf8('%s:%s:%s' % (HA1, nonce, cnonce))
if not qop:
respdig = KD(HA1, "%s:%s" % (nonce, HA2))
elif qop == 'auth' or 'auth' in qop.split(','):
noncebit = "%s:%s:%s:%s:%s" % (
nonce, ncvalue, cnonce, 'auth', HA2
)
respdig = KD(HA1, noncebit)
else:
# XXX handle auth-int.
return None
self._thread_local.last_nonce = nonce
# XXX should the partial digests be encoded too?
base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
'response="%s"' % (self.username, realm, nonce, path, respdig)
if opaque:
base += ', opaque="%s"' % opaque
if algorithm:
base += ', algorithm="%s"' % algorithm
if entdig:
base += ', digest="%s"' % entdig
if qop:
base += ', qop="auth", nc=%s, cnonce="%s"' % (ncvalue, cnonce)
return 'Digest %s' % (base)
def handle_redirect(self, r, **kwargs):
"""Reset num_401_calls counter on redirects."""
if r.is_redirect:
self._thread_local.num_401_calls = 1
def handle_401(self, r, **kwargs):
"""
Takes the given response and tries digest-auth, if needed.
:rtype: requests.Response
"""
# If response is not 4xx, do not auth
# See https://github.com/requests/requests/issues/3772
if not 400 <= r.status_code < 500:
self._thread_local.num_401_calls = 1
return r
if self._thread_local.pos is not None:
# Rewind the file position indicator of the body to where
# it was to resend the request.
r.request.body.seek(self._thread_local.pos)
s_auth = r.headers.get('www-authenticate', '')
if 'digest' in s_auth.lower() and self._thread_local.num_401_calls < 2:
self._thread_local.num_401_calls += 1
pat = re.compile(r'digest ', flags=re.IGNORECASE)
self._thread_local.chal = parse_dict_header(pat.sub('', s_auth, count=1))
# Consume content and release the original connection
# to allow our new request to reuse the same one.
r.content
r.close()
prep = r.request.copy()
extract_cookies_to_jar(prep._cookies, r.request, r.raw)
prep.prepare_cookies(prep._cookies)
prep.headers['Authorization'] = self.build_digest_header(
prep.method, prep.url)
_r = r.connection.send(prep, **kwargs)
_r.history.append(r)
_r.request = prep
return _r
self._thread_local.num_401_calls = 1
return r
def __call__(self, r):
# Initialize per-thread state, if needed
self.init_per_thread_state()
# If we have a saved nonce, skip the 401
if self._thread_local.last_nonce:
r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
try:
self._thread_local.pos = r.body.tell()
except AttributeError:
# In the case of HTTPDigestAuth being reused and the body of
# the previous request was a file-like object, pos has the
# file position of the previous body. Ensure it's set to
# None.
self._thread_local.pos = None
r.register_hook('response', self.handle_401)
r.register_hook('response', self.handle_redirect)
self._thread_local.num_401_calls = 1
return r
def __eq__(self, other):
return all([
self.username == getattr(other, 'username', None),
self.password == getattr(other, 'password', None)
])
def __ne__(self, other):
return not self == other
help.py 0000644 00000006673 15173103335 0006063 0 ustar 00 """Module containing bug report helper(s)."""
from __future__ import print_function
import json
import platform
import sys
import ssl
import idna
import urllib3
import chardet
from . import __version__ as requests_version
try:
from urllib3.contrib import pyopenssl
except ImportError:
pyopenssl = None
OpenSSL = None
cryptography = None
else:
import OpenSSL
import cryptography
def _implementation():
"""Return a dict with the Python implementation and version.
Provide both the name and the version of the Python implementation
currently running. For example, on CPython 2.7.5 it will return
{'name': 'CPython', 'version': '2.7.5'}.
This function works best on CPython and PyPy: in particular, it probably
doesn't work for Jython or IronPython. Future investigation should be done
to work out the correct shape of the code for those platforms.
"""
implementation = platform.python_implementation()
if implementation == 'CPython':
implementation_version = platform.python_version()
elif implementation == 'PyPy':
implementation_version = '%s.%s.%s' % (sys.pypy_version_info.major,
sys.pypy_version_info.minor,
sys.pypy_version_info.micro)
if sys.pypy_version_info.releaselevel != 'final':
implementation_version = ''.join([
implementation_version, sys.pypy_version_info.releaselevel
])
elif implementation == 'Jython':
implementation_version = platform.python_version() # Complete Guess
elif implementation == 'IronPython':
implementation_version = platform.python_version() # Complete Guess
else:
implementation_version = 'Unknown'
return {'name': implementation, 'version': implementation_version}
def info():
"""Generate information for a bug report."""
try:
platform_info = {
'system': platform.system(),
'release': platform.release(),
}
except IOError:
platform_info = {
'system': 'Unknown',
'release': 'Unknown',
}
implementation_info = _implementation()
urllib3_info = {'version': urllib3.__version__}
chardet_info = {'version': chardet.__version__}
pyopenssl_info = {
'version': None,
'openssl_version': '',
}
if OpenSSL:
pyopenssl_info = {
'version': OpenSSL.__version__,
'openssl_version': '%x' % OpenSSL.SSL.OPENSSL_VERSION_NUMBER,
}
cryptography_info = {
'version': getattr(cryptography, '__version__', ''),
}
idna_info = {
'version': getattr(idna, '__version__', ''),
}
system_ssl = ssl.OPENSSL_VERSION_NUMBER
system_ssl_info = {
'version': '%x' % system_ssl if system_ssl is not None else ''
}
return {
'platform': platform_info,
'implementation': implementation_info,
'system_ssl': system_ssl_info,
'using_pyopenssl': pyopenssl is not None,
'pyOpenSSL': pyopenssl_info,
'urllib3': urllib3_info,
'chardet': chardet_info,
'cryptography': cryptography_info,
'idna': idna_info,
'requests': {
'version': requests_version,
},
}
def main():
"""Pretty-print the bug information as JSON."""
print(json.dumps(info(), sort_keys=True, indent=2))
if __name__ == '__main__':
main()
_internal_utils.py 0000644 00000002110 15173103335 0010304 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests._internal_utils
~~~~~~~~~~~~~~
Provides utility functions that are consumed internally by Requests
which depend on extremely few external helpers (such as compat)
"""
from .compat import is_py2, builtin_str, str
def to_native_string(string, encoding='ascii'):
"""Given a string object, regardless of type, returns a representation of
that string in the native string type, encoding and decoding where
necessary. This assumes ASCII unless told otherwise.
"""
if isinstance(string, builtin_str):
out = string
else:
if is_py2:
out = string.encode(encoding)
else:
out = string.decode(encoding)
return out
def unicode_is_ascii(u_string):
"""Determine if unicode string only contains ASCII characters.
:param str u_string: unicode string to check. Must be unicode
and not Python 2 `str`.
:rtype: bool
"""
assert isinstance(u_string, str)
try:
u_string.encode('ascii')
return True
except UnicodeEncodeError:
return False
compat.py 0000644 00000003216 15173103335 0006404 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.compat
~~~~~~~~~~~~~~~
This module handles import compatibility issues between Python 2 and
Python 3.
"""
import chardet
import sys
# -------
# Pythons
# -------
# Syntax sugar.
_ver = sys.version_info
#: Python 2.x?
is_py2 = (_ver[0] == 2)
#: Python 3.x?
is_py3 = (_ver[0] == 3)
try:
import simplejson as json
except ImportError:
import json
# ---------
# Specifics
# ---------
if is_py2:
from urllib import (
quote, unquote, quote_plus, unquote_plus, urlencode, getproxies,
proxy_bypass, proxy_bypass_environment, getproxies_environment)
from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
from urllib2 import parse_http_list
import cookielib
from Cookie import Morsel
from StringIO import StringIO
from collections import Callable, Mapping, MutableMapping, OrderedDict
builtin_str = str
bytes = str
str = unicode
basestring = basestring
numeric_types = (int, long, float)
integer_types = (int, long)
elif is_py3:
from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
from urllib.request import parse_http_list, getproxies, proxy_bypass, proxy_bypass_environment, getproxies_environment
from http import cookiejar as cookielib
from http.cookies import Morsel
from io import StringIO
from collections import OrderedDict
from collections.abc import Callable, Mapping, MutableMapping
builtin_str = str
str = str
bytes = bytes
basestring = (str, bytes)
numeric_types = (int, float)
integer_types = (int,)
cookies.py 0000644 00000043776 15173103335 0006574 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `cookielib.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
"""
import copy
import time
import calendar
from ._internal_utils import to_native_string
from .compat import cookielib, urlparse, urlunparse, Morsel, MutableMapping
try:
import threading
except ImportError:
import dummy_threading as threading
class MockRequest(object):
"""Wraps a `requests.Request` to mimic a `urllib2.Request`.
The code in `cookielib.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
"""
def __init__(self, request):
self._r = request
self._new_headers = {}
self.type = urlparse(self._r.url).scheme
def get_type(self):
return self.type
def get_host(self):
return urlparse(self._r.url).netloc
def get_origin_req_host(self):
return self.get_host()
def get_full_url(self):
# Only return the response's URL if the user hadn't set the Host
# header
if not self._r.headers.get('Host'):
return self._r.url
# If they did set it, retrieve it and reconstruct the expected domain
host = to_native_string(self._r.headers['Host'], encoding='utf-8')
parsed = urlparse(self._r.url)
# Reconstruct the URL as we expect it
return urlunparse([
parsed.scheme, host, parsed.path, parsed.params, parsed.query,
parsed.fragment
])
def is_unverifiable(self):
return True
def has_header(self, name):
return name in self._r.headers or name in self._new_headers
def get_header(self, name, default=None):
return self._r.headers.get(name, self._new_headers.get(name, default))
def add_header(self, key, val):
"""cookielib has no legitimate use for this method; add it back if you find one."""
raise NotImplementedError("Cookie headers should be added with add_unredirected_header()")
def add_unredirected_header(self, name, value):
self._new_headers[name] = value
def get_new_headers(self):
return self._new_headers
@property
def unverifiable(self):
return self.is_unverifiable()
@property
def origin_req_host(self):
return self.get_origin_req_host()
@property
def host(self):
return self.get_host()
class MockResponse(object):
"""Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `cookielib` expects to see them.
"""
def __init__(self, headers):
"""Make a MockResponse for `cookielib` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
"""
self._headers = headers
def info(self):
return self._headers
def getheaders(self, name):
self._headers.getheaders(name)
def extract_cookies_to_jar(jar, request, response):
"""Extract the cookies from the response into a CookieJar.
:param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)
:param request: our own requests.Request object
:param response: urllib3.HTTPResponse object
"""
if not (hasattr(response, '_original_response') and
response._original_response):
return
# the _original_response field is the wrapped httplib.HTTPResponse object,
req = MockRequest(request)
# pull out the HTTPMessage with the headers and put it in the mock:
res = MockResponse(response._original_response.msg)
jar.extract_cookies(res, req)
def get_cookie_header(jar, request):
"""
Produce an appropriate Cookie header string to be sent with `request`, or None.
:rtype: str
"""
r = MockRequest(request)
jar.add_cookie_header(r)
return r.get_new_headers().get('Cookie')
def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
"""Unsets a cookie by name, by default over all domains and paths.
Wraps CookieJar.clear(), is O(n).
"""
clearables = []
for cookie in cookiejar:
if cookie.name != name:
continue
if domain is not None and domain != cookie.domain:
continue
if path is not None and path != cookie.path:
continue
clearables.append((cookie.domain, cookie.path, cookie.name))
for domain, path, name in clearables:
cookiejar.clear(domain, path, name)
class CookieConflictError(RuntimeError):
"""There are two cookies that meet the criteria specified in the cookie jar.
Use .get and .set and include domain and path args in order to be more specific.
"""
class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
"""Compatibility class; is a cookielib.CookieJar, but exposes a dict
interface.
This is the CookieJar we create by default for requests and sessions that
don't specify one, since some clients may expect response.cookies and
session.cookies to support dict operations.
Requests does not use the dict interface internally; it's just for
compatibility with external client code. All requests code should work
out of the box with externally provided instances of ``CookieJar``, e.g.
``LWPCookieJar`` and ``FileCookieJar``.
Unlike a regular CookieJar, this class is pickleable.
.. warning:: dictionary operations that are normally O(1) may be O(n).
"""
def get(self, name, default=None, domain=None, path=None):
"""Dict-like get() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
.. warning:: operation is O(n), not O(1).
"""
try:
return self._find_no_duplicates(name, domain, path)
except KeyError:
return default
def set(self, name, value, **kwargs):
"""Dict-like set() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
"""
# support client code that unsets cookies by assignment of a None value:
if value is None:
remove_cookie_by_name(self, name, domain=kwargs.get('domain'), path=kwargs.get('path'))
return
if isinstance(value, Morsel):
c = morsel_to_cookie(value)
else:
c = create_cookie(name, value, **kwargs)
self.set_cookie(c)
return c
def iterkeys(self):
"""Dict-like iterkeys() that returns an iterator of names of cookies
from the jar.
.. seealso:: itervalues() and iteritems().
"""
for cookie in iter(self):
yield cookie.name
def keys(self):
"""Dict-like keys() that returns a list of names of cookies from the
jar.
.. seealso:: values() and items().
"""
return list(self.iterkeys())
def itervalues(self):
"""Dict-like itervalues() that returns an iterator of values of cookies
from the jar.
.. seealso:: iterkeys() and iteritems().
"""
for cookie in iter(self):
yield cookie.value
def values(self):
"""Dict-like values() that returns a list of values of cookies from the
jar.
.. seealso:: keys() and items().
"""
return list(self.itervalues())
def iteritems(self):
"""Dict-like iteritems() that returns an iterator of name-value tuples
from the jar.
.. seealso:: iterkeys() and itervalues().
"""
for cookie in iter(self):
yield cookie.name, cookie.value
def items(self):
"""Dict-like items() that returns a list of name-value tuples from the
jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
vanilla python dict of key value pairs.
.. seealso:: keys() and values().
"""
return list(self.iteritems())
def list_domains(self):
"""Utility method to list all the domains in the jar."""
domains = []
for cookie in iter(self):
if cookie.domain not in domains:
domains.append(cookie.domain)
return domains
def list_paths(self):
"""Utility method to list all the paths in the jar."""
paths = []
for cookie in iter(self):
if cookie.path not in paths:
paths.append(cookie.path)
return paths
def multiple_domains(self):
"""Returns True if there are multiple domains in the jar.
Returns False otherwise.
:rtype: bool
"""
domains = []
for cookie in iter(self):
if cookie.domain is not None and cookie.domain in domains:
return True
domains.append(cookie.domain)
return False # there is only one domain in jar
def get_dict(self, domain=None, path=None):
"""Takes as an argument an optional domain and path and returns a plain
old Python dict of name-value pairs of cookies that meet the
requirements.
:rtype: dict
"""
dictionary = {}
for cookie in iter(self):
if (
(domain is None or cookie.domain == domain) and
(path is None or cookie.path == path)
):
dictionary[cookie.name] = cookie.value
return dictionary
def __contains__(self, name):
try:
return super(RequestsCookieJar, self).__contains__(name)
except CookieConflictError:
return True
def __getitem__(self, name):
"""Dict-like __getitem__() for compatibility with client code. Throws
exception if there are more than one cookie with name. In that case,
use the more explicit get() method instead.
.. warning:: operation is O(n), not O(1).
"""
return self._find_no_duplicates(name)
def __setitem__(self, name, value):
"""Dict-like __setitem__ for compatibility with client code. Throws
exception if there is already a cookie of that name in the jar. In that
case, use the more explicit set() method instead.
"""
self.set(name, value)
def __delitem__(self, name):
"""Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s
``remove_cookie_by_name()``.
"""
remove_cookie_by_name(self, name)
def set_cookie(self, cookie, *args, **kwargs):
if hasattr(cookie.value, 'startswith') and cookie.value.startswith('"') and cookie.value.endswith('"'):
cookie.value = cookie.value.replace('\\"', '')
return super(RequestsCookieJar, self).set_cookie(cookie, *args, **kwargs)
def update(self, other):
"""Updates this jar with cookies from another CookieJar or dict-like"""
if isinstance(other, cookielib.CookieJar):
for cookie in other:
self.set_cookie(copy.copy(cookie))
else:
super(RequestsCookieJar, self).update(other)
def _find(self, name, domain=None, path=None):
"""Requests uses this method internally to get cookie values.
If there are conflicting cookies, _find arbitrarily chooses one.
See _find_no_duplicates if you want an exception thrown if there are
conflicting cookies.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:return: cookie.value
"""
for cookie in iter(self):
if cookie.name == name:
if domain is None or cookie.domain == domain:
if path is None or cookie.path == path:
return cookie.value
raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
def _find_no_duplicates(self, name, domain=None, path=None):
"""Both ``__get_item__`` and ``get`` call this function: it's never
used elsewhere in Requests.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:raises KeyError: if cookie is not found
:raises CookieConflictError: if there are multiple cookies
that match name and optionally domain and path
:return: cookie.value
"""
toReturn = None
for cookie in iter(self):
if cookie.name == name:
if domain is None or cookie.domain == domain:
if path is None or cookie.path == path:
if toReturn is not None: # if there are multiple cookies that meet passed in criteria
raise CookieConflictError('There are multiple cookies with name, %r' % (name))
toReturn = cookie.value # we will eventually return this as long as no cookie conflict
if toReturn:
return toReturn
raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
def __getstate__(self):
"""Unlike a normal CookieJar, this class is pickleable."""
state = self.__dict__.copy()
# remove the unpickleable RLock object
state.pop('_cookies_lock')
return state
def __setstate__(self, state):
"""Unlike a normal CookieJar, this class is pickleable."""
self.__dict__.update(state)
if '_cookies_lock' not in self.__dict__:
self._cookies_lock = threading.RLock()
def copy(self):
"""Return a copy of this RequestsCookieJar."""
new_cj = RequestsCookieJar()
new_cj.set_policy(self.get_policy())
new_cj.update(self)
return new_cj
def get_policy(self):
"""Return the CookiePolicy instance used."""
return self._policy
def _copy_cookie_jar(jar):
if jar is None:
return None
if hasattr(jar, 'copy'):
# We're dealing with an instance of RequestsCookieJar
return jar.copy()
# We're dealing with a generic CookieJar instance
new_jar = copy.copy(jar)
new_jar.clear()
for cookie in jar:
new_jar.set_cookie(copy.copy(cookie))
return new_jar
def create_cookie(name, value, **kwargs):
"""Make a cookie from underspecified parameters.
By default, the pair of `name` and `value` will be set for the domain ''
and sent on every request (this is sometimes called a "supercookie").
"""
result = {
'version': 0,
'name': name,
'value': value,
'port': None,
'domain': '',
'path': '/',
'secure': False,
'expires': None,
'discard': True,
'comment': None,
'comment_url': None,
'rest': {'HttpOnly': None},
'rfc2109': False,
}
badargs = set(kwargs) - set(result)
if badargs:
err = 'create_cookie() got unexpected keyword arguments: %s'
raise TypeError(err % list(badargs))
result.update(kwargs)
result['port_specified'] = bool(result['port'])
result['domain_specified'] = bool(result['domain'])
result['domain_initial_dot'] = result['domain'].startswith('.')
result['path_specified'] = bool(result['path'])
return cookielib.Cookie(**result)
def morsel_to_cookie(morsel):
"""Convert a Morsel object into a Cookie containing the one k/v pair."""
expires = None
if morsel['max-age']:
try:
expires = int(time.time() + int(morsel['max-age']))
except ValueError:
raise TypeError('max-age: %s must be integer' % morsel['max-age'])
elif morsel['expires']:
time_template = '%a, %d-%b-%Y %H:%M:%S GMT'
expires = calendar.timegm(
time.strptime(morsel['expires'], time_template)
)
return create_cookie(
comment=morsel['comment'],
comment_url=bool(morsel['comment']),
discard=False,
domain=morsel['domain'],
expires=expires,
name=morsel.key,
path=morsel['path'],
port=None,
rest={'HttpOnly': morsel['httponly']},
rfc2109=False,
secure=bool(morsel['secure']),
value=morsel.value,
version=morsel['version'] or 0,
)
def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
"""Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
:rtype: CookieJar
"""
if cookiejar is None:
cookiejar = RequestsCookieJar()
if cookie_dict is not None:
names_from_jar = [cookie.name for cookie in cookiejar]
for name in cookie_dict:
if overwrite or (name not in names_from_jar):
cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
return cookiejar
def merge_cookies(cookiejar, cookies):
"""Add cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
:rtype: CookieJar
"""
if not isinstance(cookiejar, cookielib.CookieJar):
raise ValueError('You can only merge into CookieJar')
if isinstance(cookies, dict):
cookiejar = cookiejar_from_dict(
cookies, cookiejar=cookiejar, overwrite=False)
elif isinstance(cookies, cookielib.CookieJar):
try:
cookiejar.update(cookies)
except AttributeError:
for cookie_in_jar in cookies:
cookiejar.set_cookie(cookie_in_jar)
return cookiejar
sessions.py 0000644 00000071525 15173103336 0007000 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.session
~~~~~~~~~~~~~~~~
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
"""
import os
import sys
import time
from datetime import timedelta
from .auth import _basic_auth_str
from .compat import cookielib, is_py3, OrderedDict, urljoin, urlparse, Mapping
from .cookies import (
cookiejar_from_dict, extract_cookies_to_jar, RequestsCookieJar, merge_cookies)
from .models import Request, PreparedRequest, DEFAULT_REDIRECT_LIMIT
from .hooks import default_hooks, dispatch_hook
from ._internal_utils import to_native_string
from .utils import to_key_val_list, default_headers, DEFAULT_PORTS
from .exceptions import (
TooManyRedirects, InvalidSchema, ChunkedEncodingError, ContentDecodingError)
from .structures import CaseInsensitiveDict
from .adapters import HTTPAdapter
from .utils import (
requote_uri, get_environ_proxies, get_netrc_auth, should_bypass_proxies,
get_auth_from_url, rewind_body
)
from .status_codes import codes
# formerly defined here, reexposed here for backward compatibility
from .models import REDIRECT_STATI
# Preferred clock, based on which one is more accurate on a given system.
if sys.platform == 'win32':
try: # Python 3.4+
preferred_clock = time.perf_counter
except AttributeError: # Earlier than Python 3.
preferred_clock = time.clock
else:
preferred_clock = time.time
def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
"""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`
"""
if session_setting is None:
return request_setting
if request_setting is None:
return session_setting
# Bypass if not a dictionary (e.g. verify)
if not (
isinstance(session_setting, Mapping) and
isinstance(request_setting, Mapping)
):
return request_setting
merged_setting = dict_class(to_key_val_list(session_setting))
merged_setting.update(to_key_val_list(request_setting))
# Remove keys that are set to None. Extract keys first to avoid altering
# the dictionary during iteration.
none_keys = [k for (k, v) in merged_setting.items() if v is None]
for key in none_keys:
del merged_setting[key]
return merged_setting
def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict):
"""Properly merges both requests and session hooks.
This is necessary because when request_hooks == {'response': []}, the
merge breaks Session hooks entirely.
"""
if session_hooks is None or session_hooks.get('response') == []:
return request_hooks
if request_hooks is None or request_hooks.get('response') == []:
return session_hooks
return merge_setting(request_hooks, session_hooks, dict_class)
class SessionRedirectMixin(object):
def get_redirect_target(self, resp):
"""Receives a Response. Returns a redirect URI or ``None``"""
# Due to the nature of how requests processes redirects this method will
# be called at least once upon the original response and at least twice
# on each subsequent redirect response (if any).
# If a custom mixin is used to handle this logic, it may be advantageous
# to cache the redirect location onto the response object as a private
# attribute.
if resp.is_redirect:
location = resp.headers['location']
# Currently the underlying http module on py3 decode headers
# in latin1, but empirical evidence suggests that latin1 is very
# rarely used with non-ASCII characters in HTTP headers.
# It is more likely to get UTF8 header rather than latin1.
# This causes incorrect handling of UTF8 encoded location headers.
# To solve this, we re-encode the location in latin1.
if is_py3:
location = location.encode('latin1')
return to_native_string(location, 'utf8')
return None
def should_strip_auth(self, old_url, new_url):
"""Decide whether Authorization header should be removed when redirecting"""
old_parsed = urlparse(old_url)
new_parsed = urlparse(new_url)
if old_parsed.hostname != new_parsed.hostname:
return True
# Special case: allow http -> https redirect when using the standard
# ports. This isn't specified by RFC 7235, but is kept to avoid
# breaking backwards compatibility with older versions of requests
# that allowed any redirects on the same host.
if (old_parsed.scheme == 'http' and old_parsed.port in (80, None)
and new_parsed.scheme == 'https' and new_parsed.port in (443, None)):
return False
# Handle default port usage corresponding to scheme.
changed_port = old_parsed.port != new_parsed.port
changed_scheme = old_parsed.scheme != new_parsed.scheme
default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None)
if (not changed_scheme and old_parsed.port in default_port
and new_parsed.port in default_port):
return False
# Standard case: root URI must match
return changed_port or changed_scheme
def resolve_redirects(self, resp, req, stream=False, timeout=None,
verify=True, cert=None, proxies=None, yield_requests=False, **adapter_kwargs):
"""Receives a Response. Returns a generator of Responses or Requests."""
hist = [] # keep track of history
url = self.get_redirect_target(resp)
previous_fragment = urlparse(req.url).fragment
while url:
prepared_request = req.copy()
# Update history and keep track of redirects.
# resp.history must ignore the original request in this loop
hist.append(resp)
resp.history = hist[1:]
try:
resp.content # Consume socket so it can be released
except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
resp.raw.read(decode_content=False)
if len(resp.history) >= self.max_redirects:
raise TooManyRedirects('Exceeded %s redirects.' % self.max_redirects, response=resp)
# Release the connection back into the pool.
resp.close()
# Handle redirection without scheme (see: RFC 1808 Section 4)
if url.startswith('//'):
parsed_rurl = urlparse(resp.url)
url = '%s:%s' % (to_native_string(parsed_rurl.scheme), url)
# Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2)
parsed = urlparse(url)
if parsed.fragment == '' and previous_fragment:
parsed = parsed._replace(fragment=previous_fragment)
elif parsed.fragment:
previous_fragment = parsed.fragment
url = parsed.geturl()
# Facilitate relative 'location' headers, as allowed by RFC 7231.
# (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
# Compliant with RFC3986, we percent encode the url.
if not parsed.netloc:
url = urljoin(resp.url, requote_uri(url))
else:
url = requote_uri(url)
prepared_request.url = to_native_string(url)
self.rebuild_method(prepared_request, resp)
# https://github.com/requests/requests/issues/1084
if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):
# https://github.com/requests/requests/issues/3490
purged_headers = ('Content-Length', 'Content-Type', 'Transfer-Encoding')
for header in purged_headers:
prepared_request.headers.pop(header, None)
prepared_request.body = None
headers = prepared_request.headers
try:
del headers['Cookie']
except KeyError:
pass
# Extract any cookies sent on the response to the cookiejar
# in the new request. Because we've mutated our copied prepared
# request, use the old one that we haven't yet touched.
extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
merge_cookies(prepared_request._cookies, self.cookies)
prepared_request.prepare_cookies(prepared_request._cookies)
# Rebuild auth and proxy information.
proxies = self.rebuild_proxies(prepared_request, proxies)
self.rebuild_auth(prepared_request, resp)
# A failed tell() sets `_body_position` to `object()`. This non-None
# value ensures `rewindable` will be True, allowing us to raise an
# UnrewindableBodyError, instead of hanging the connection.
rewindable = (
prepared_request._body_position is not None and
('Content-Length' in headers or 'Transfer-Encoding' in headers)
)
# Attempt to rewind consumed file-like object.
if rewindable:
rewind_body(prepared_request)
# Override the original request.
req = prepared_request
if yield_requests:
yield req
else:
resp = self.send(
req,
stream=stream,
timeout=timeout,
verify=verify,
cert=cert,
proxies=proxies,
allow_redirects=False,
**adapter_kwargs
)
extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)
# extract redirect url, if any, for the next loop
url = self.get_redirect_target(resp)
yield resp
def rebuild_auth(self, prepared_request, response):
"""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.
"""
headers = prepared_request.headers
url = prepared_request.url
if 'Authorization' in headers and self.should_strip_auth(response.request.url, url):
# If we get redirected to a new host, we should strip out any
# authentication headers.
del headers['Authorization']
# .netrc might have more auth for us on our new host.
new_auth = get_netrc_auth(url) if self.trust_env else None
if new_auth is not None:
prepared_request.prepare_auth(new_auth)
return
def rebuild_proxies(self, prepared_request, proxies):
"""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
"""
proxies = proxies if proxies is not None else {}
headers = prepared_request.headers
url = prepared_request.url
scheme = urlparse(url).scheme
new_proxies = proxies.copy()
no_proxy = proxies.get('no_proxy')
bypass_proxy = should_bypass_proxies(url, no_proxy=no_proxy)
if self.trust_env and not bypass_proxy:
environ_proxies = get_environ_proxies(url, no_proxy=no_proxy)
proxy = environ_proxies.get(scheme, environ_proxies.get('all'))
if proxy:
new_proxies.setdefault(scheme, proxy)
if 'Proxy-Authorization' in headers:
del headers['Proxy-Authorization']
try:
username, password = get_auth_from_url(new_proxies[scheme])
except KeyError:
username, password = None, None
# urllib3 handles proxy authorization for us in the standard adapter.
# Avoid appending this to TLS tunneled requests where it may be leaked.
if not scheme.startswith('https') and username and password:
headers['Proxy-Authorization'] = _basic_auth_str(username, password)
return new_proxies
def rebuild_method(self, prepared_request, response):
"""When being redirected we may want to change the method of the request
based on certain specs or browser behavior.
"""
method = prepared_request.method
# https://tools.ietf.org/html/rfc7231#section-6.4.4
if response.status_code == codes.see_other and method != 'HEAD':
method = 'GET'
# Do what the browsers do, despite standards...
# First, turn 302s into GETs.
if response.status_code == codes.found and method != 'HEAD':
method = 'GET'
# Second, if a POST is responded to with a 301, turn it into a GET.
# This bizarre behaviour is explained in Issue 1704.
if response.status_code == codes.moved and method == 'POST':
method = 'GET'
prepared_request.method = method
class Session(SessionRedirectMixin):
"""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]>
"""
__attrs__ = [
'headers', 'cookies', 'auth', 'proxies', 'hooks', 'params', 'verify',
'cert', 'prefetch', 'adapters', 'stream', 'trust_env',
'max_redirects',
]
def __init__(self):
#: A case-insensitive dictionary of headers to be sent on each
#: :class:`Request <Request>` sent from this
#: :class:`Session <Session>`.
self.headers = default_headers()
#: Default Authentication tuple or object to attach to
#: :class:`Request <Request>`.
self.auth = None
#: Dictionary mapping protocol or protocol and host to the URL of the proxy
#: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
#: be used on each :class:`Request <Request>`.
self.proxies = {}
#: Event-handling hooks.
self.hooks = default_hooks()
#: Dictionary of querystring data to attach to each
#: :class:`Request <Request>`. The dictionary values may be lists for
#: representing multivalued query parameters.
self.params = {}
#: Stream response content default.
self.stream = False
#: SSL Verification default.
self.verify = True
#: SSL client certificate default, if String, path to ssl client
#: cert file (.pem). If Tuple, ('cert', 'key') pair.
self.cert = None
#: Maximum number of redirects allowed. If the request exceeds this
#: limit, a :class:`TooManyRedirects` exception is raised.
#: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
#: 30.
self.max_redirects = DEFAULT_REDIRECT_LIMIT
#: Trust environment settings for proxy configuration, default
#: authentication and similar.
self.trust_env = True
#: A CookieJar containing all currently outstanding cookies set on this
#: session. By default it is a
#: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
#: may be any other ``cookielib.CookieJar`` compatible object.
self.cookies = cookiejar_from_dict({})
# Default connection adapters.
self.adapters = OrderedDict()
self.mount('https://', HTTPAdapter())
self.mount('http://', HTTPAdapter())
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
def prepare_request(self, request):
"""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
"""
cookies = request.cookies or {}
# Bootstrap CookieJar.
if not isinstance(cookies, cookielib.CookieJar):
cookies = cookiejar_from_dict(cookies)
# Merge with session cookies
merged_cookies = merge_cookies(
merge_cookies(RequestsCookieJar(), self.cookies), cookies)
# Set environment's basic authentication if not explicitly set.
auth = request.auth
if self.trust_env and not auth and not self.auth:
auth = get_netrc_auth(request.url)
p = PreparedRequest()
p.prepare(
method=request.method.upper(),
url=request.url,
files=request.files,
data=request.data,
json=request.json,
headers=merge_setting(request.headers, self.headers, dict_class=CaseInsensitiveDict),
params=merge_setting(request.params, self.params),
auth=merge_setting(auth, self.auth),
cookies=merged_cookies,
hooks=merge_hooks(request.hooks, self.hooks),
)
return p
def request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None,
auth=None, timeout=None, allow_redirects=True, proxies=None,
hooks=None, stream=None, verify=None, cert=None, json=None):
"""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``.
:param cert: (optional) if String, path to ssl client cert file (.pem).
If Tuple, ('cert', 'key') pair.
:rtype: requests.Response
"""
# Create the Request.
req = Request(
method=method.upper(),
url=url,
headers=headers,
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or {}
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
return resp
def get(self, url, **kwargs):
r"""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
"""
kwargs.setdefault('allow_redirects', True)
return self.request('GET', url, **kwargs)
def options(self, url, **kwargs):
r"""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
"""
kwargs.setdefault('allow_redirects', True)
return self.request('OPTIONS', url, **kwargs)
def head(self, url, **kwargs):
r"""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
"""
kwargs.setdefault('allow_redirects', False)
return self.request('HEAD', url, **kwargs)
def post(self, url, data=None, json=None, **kwargs):
r"""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
"""
return self.request('POST', url, data=data, json=json, **kwargs)
def put(self, url, data=None, **kwargs):
r"""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
"""
return self.request('PUT', url, data=data, **kwargs)
def patch(self, url, data=None, **kwargs):
r"""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
"""
return self.request('PATCH', url, data=data, **kwargs)
def delete(self, url, **kwargs):
r"""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
"""
return self.request('DELETE', url, **kwargs)
def send(self, request, **kwargs):
"""Send a given PreparedRequest.
:rtype: requests.Response
"""
# Set defaults that the hooks can utilize to ensure they always have
# the correct parameters to reproduce the previous request.
kwargs.setdefault('stream', self.stream)
kwargs.setdefault('verify', self.verify)
kwargs.setdefault('cert', self.cert)
kwargs.setdefault('proxies', self.proxies)
# It's possible that users might accidentally send a Request object.
# Guard against that specific failure case.
if isinstance(request, Request):
raise ValueError('You can only send PreparedRequests.')
# Set up variables needed for resolve_redirects and dispatching of hooks
allow_redirects = kwargs.pop('allow_redirects', True)
stream = kwargs.get('stream')
hooks = request.hooks
# Get the appropriate adapter to use
adapter = self.get_adapter(url=request.url)
# Start time (approximately) of the request
start = preferred_clock()
# Send the request
r = adapter.send(request, **kwargs)
# Total elapsed time of the request (approximately)
elapsed = preferred_clock() - start
r.elapsed = timedelta(seconds=elapsed)
# Response manipulation hooks
r = dispatch_hook('response', hooks, r, **kwargs)
# Persist cookies
if r.history:
# If the hooks create history then we want those cookies too
for resp in r.history:
extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
extract_cookies_to_jar(self.cookies, request, r.raw)
# Redirect resolving generator.
gen = self.resolve_redirects(r, request, **kwargs)
# Resolve redirects if allowed.
history = [resp for resp in gen] if allow_redirects else []
# Shuffle things around if there's history.
if history:
# Insert the first (original) request at the start
history.insert(0, r)
# Get the last request made
r = history.pop()
r.history = history
# If redirects aren't being followed, store the response on the Request for Response.next().
if not allow_redirects:
try:
r._next = next(self.resolve_redirects(r, request, yield_requests=True, **kwargs))
except StopIteration:
pass
if not stream:
r.content
return r
def merge_environment_settings(self, url, proxies, stream, verify, cert):
"""
Check the environment and merge it with some settings.
:rtype: dict
"""
# Gather clues from the surrounding environment.
if self.trust_env:
# Set environment's proxies.
no_proxy = proxies.get('no_proxy') if proxies is not None else None
env_proxies = get_environ_proxies(url, no_proxy=no_proxy)
for (k, v) in env_proxies.items():
proxies.setdefault(k, v)
# Look for requests environment configuration and be compatible
# with cURL.
if verify is True or verify is None:
verify = (os.environ.get('REQUESTS_CA_BUNDLE') or
os.environ.get('CURL_CA_BUNDLE'))
# Merge all the kwargs.
proxies = merge_setting(proxies, self.proxies)
stream = merge_setting(stream, self.stream)
verify = merge_setting(verify, self.verify)
cert = merge_setting(cert, self.cert)
return {'verify': verify, 'proxies': proxies, 'stream': stream,
'cert': cert}
def get_adapter(self, url):
"""
Returns the appropriate connection adapter for the given URL.
:rtype: requests.adapters.BaseAdapter
"""
for (prefix, adapter) in self.adapters.items():
if url.lower().startswith(prefix.lower()):
return adapter
# Nothing matches :-/
raise InvalidSchema("No connection adapters were found for '%s'" % url)
def close(self):
"""Closes all adapters and as such the session"""
for v in self.adapters.values():
v.close()
def mount(self, prefix, adapter):
"""Registers a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
"""
self.adapters[prefix] = adapter
keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
for key in keys_to_move:
self.adapters[key] = self.adapters.pop(key)
def __getstate__(self):
state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
return state
def __setstate__(self, state):
for attr, value in state.items():
setattr(self, attr, value)
def session():
"""
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
"""
return Session()
certs.py 0000644 00000001305 15173103336 0006237 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.certs
~~~~~~~~~~~~~~
This module returns the preferred default CA certificate bundle. There is
only one — the one from the certifi package.
If you are packaging Requests, e.g., for a Linux distribution or a managed
environment, you can change the definition of where() to return a separately
packaged CA bundle.
This Fedora-patched package returns "/etc/pki/tls/certs/ca-bundle.crt" provided
by the ca-certificates RPM package.
"""
try:
from certifi import where
except ImportError:
def where():
"""Return the absolute path to the system CA bundle."""
return '/etc/pki/tls/certs/ca-bundle.crt'
if __name__ == '__main__':
print(where())
__version__.py 0000644 00000000664 15173103336 0007407 0 ustar 00 # .-. .-. .-. . . .-. .-. .-. .-.
# |( |- |.| | | |- `-. | `-.
# ' ' `-' `-`.`-' `-' `-' ' `-'
__title__ = 'requests'
__description__ = 'Python HTTP for Humans.'
__url__ = 'http://python-requests.org'
__version__ = '2.20.0'
__build__ = 0x022000
__author__ = 'Kenneth Reitz'
__author_email__ = 'me@kennethreitz.org'
__license__ = 'Apache 2.0'
__copyright__ = 'Copyright 2018 Kenneth Reitz'
__cake__ = u'\u2728 \U0001f370 \u2728'
exceptions.py 0000644 00000006161 15173103336 0007305 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.exceptions
~~~~~~~~~~~~~~~~~~~
This module contains the set of Requests' exceptions.
"""
from urllib3.exceptions import HTTPError as BaseHTTPError
class RequestException(IOError):
"""There was an ambiguous exception that occurred while handling your
request.
"""
def __init__(self, *args, **kwargs):
"""Initialize RequestException with `request` and `response` objects."""
response = kwargs.pop('response', None)
self.response = response
self.request = kwargs.pop('request', None)
if (response is not None and not self.request and
hasattr(response, 'request')):
self.request = self.response.request
super(RequestException, self).__init__(*args, **kwargs)
class HTTPError(RequestException):
"""An HTTP error occurred."""
class ConnectionError(RequestException):
"""A Connection error occurred."""
class ProxyError(ConnectionError):
"""A proxy error occurred."""
class SSLError(ConnectionError):
"""An SSL error occurred."""
class Timeout(RequestException):
"""The request timed out.
Catching this error will catch both
:exc:`~requests.exceptions.ConnectTimeout` and
:exc:`~requests.exceptions.ReadTimeout` errors.
"""
class ConnectTimeout(ConnectionError, Timeout):
"""The request timed out while trying to connect to the remote server.
Requests that produced this error are safe to retry.
"""
class ReadTimeout(Timeout):
"""The server did not send any data in the allotted amount of time."""
class URLRequired(RequestException):
"""A valid URL is required to make a request."""
class TooManyRedirects(RequestException):
"""Too many redirects."""
class MissingSchema(RequestException, ValueError):
"""The URL schema (e.g. http or https) is missing."""
class InvalidSchema(RequestException, ValueError):
"""See defaults.py for valid schemas."""
class InvalidURL(RequestException, ValueError):
"""The URL provided was somehow invalid."""
class InvalidHeader(RequestException, ValueError):
"""The header value provided was somehow invalid."""
class InvalidProxyURL(InvalidURL):
"""The proxy URL provided is invalid."""
class ChunkedEncodingError(RequestException):
"""The server declared chunked encoding but sent an invalid chunk."""
class ContentDecodingError(RequestException, BaseHTTPError):
"""Failed to decode response content"""
class StreamConsumedError(RequestException, TypeError):
"""The content for this response was already consumed"""
class RetryError(RequestException):
"""Custom retries logic failed"""
class UnrewindableBodyError(RequestException):
"""Requests encountered an error when trying to rewind a body"""
# Warnings
class RequestsWarning(Warning):
"""Base warning for Requests."""
pass
class FileModeWarning(RequestsWarning, DeprecationWarning):
"""A file was opened in text mode, but Requests determined its binary length."""
pass
class RequestsDependencyWarning(RequestsWarning):
"""An imported dependency doesn't match the expected version range."""
pass
models.py 0000644 00000102641 15173103336 0006407 0 ustar 00 # -*- coding: utf-8 -*-
"""
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
"""
import datetime
import sys
# Import encoding now, to avoid implicit import later.
# Implicit import within threads may cause LookupError when standard library is in a ZIP,
# such as in Embedded Python. See https://github.com/requests/requests/issues/3578.
import encodings.idna
from urllib3.fields import RequestField
from urllib3.filepost import encode_multipart_formdata
from urllib3.util import parse_url
from urllib3.exceptions import (
DecodeError, ReadTimeoutError, ProtocolError, LocationParseError)
from io import UnsupportedOperation
from .hooks import default_hooks
from .structures import CaseInsensitiveDict
from .auth import HTTPBasicAuth
from .cookies import cookiejar_from_dict, get_cookie_header, _copy_cookie_jar
from .exceptions import (
HTTPError, MissingSchema, InvalidURL, ChunkedEncodingError,
ContentDecodingError, ConnectionError, StreamConsumedError)
from ._internal_utils import to_native_string, unicode_is_ascii
from .utils import (
guess_filename, get_auth_from_url, requote_uri,
stream_decode_response_unicode, to_key_val_list, parse_header_links,
iter_slices, guess_json_utf, super_len, check_header_validity)
from .compat import (
Callable, Mapping,
cookielib, urlunparse, urlsplit, urlencode, str, bytes,
is_py2, chardet, builtin_str, basestring)
from .compat import json as complexjson
from .status_codes import codes
#: The set of HTTP status codes that indicate an automatically
#: processable redirect.
REDIRECT_STATI = (
codes.moved, # 301
codes.found, # 302
codes.other, # 303
codes.temporary_redirect, # 307
codes.permanent_redirect, # 308
)
DEFAULT_REDIRECT_LIMIT = 30
CONTENT_CHUNK_SIZE = 10 * 1024
ITER_CHUNK_SIZE = 512
class RequestEncodingMixin(object):
@property
def path_url(self):
"""Build the path URL to use."""
url = []
p = urlsplit(self.url)
path = p.path
if not path:
path = '/'
url.append(path)
query = p.query
if query:
url.append('?')
url.append(query)
return ''.join(url)
@staticmethod
def _encode_params(data):
"""Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
"""
if isinstance(data, (str, bytes)):
return data
elif hasattr(data, 'read'):
return data
elif hasattr(data, '__iter__'):
result = []
for k, vs in to_key_val_list(data):
if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
vs = [vs]
for v in vs:
if v is not None:
result.append(
(k.encode('utf-8') if isinstance(k, str) else k,
v.encode('utf-8') if isinstance(v, str) else v))
return urlencode(result, doseq=True)
else:
return data
@staticmethod
def _encode_files(files, data):
"""Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
"""
if (not files):
raise ValueError("Files must be provided.")
elif isinstance(data, basestring):
raise ValueError("Data must not be a string.")
new_fields = []
fields = to_key_val_list(data or {})
files = to_key_val_list(files or {})
for field, val in fields:
if isinstance(val, basestring) or not hasattr(val, '__iter__'):
val = [val]
for v in val:
if v is not None:
# Don't call str() on bytestrings: in Py3 it all goes wrong.
if not isinstance(v, bytes):
v = str(v)
new_fields.append(
(field.decode('utf-8') if isinstance(field, bytes) else field,
v.encode('utf-8') if isinstance(v, str) else v))
for (k, v) in files:
# support for explicit filename
ft = None
fh = None
if isinstance(v, (tuple, list)):
if len(v) == 2:
fn, fp = v
elif len(v) == 3:
fn, fp, ft = v
else:
fn, fp, ft, fh = v
else:
fn = guess_filename(v) or k
fp = v
if isinstance(fp, (str, bytes, bytearray)):
fdata = fp
elif hasattr(fp, 'read'):
fdata = fp.read()
elif fp is None:
continue
else:
fdata = fp
rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
rf.make_multipart(content_type=ft)
new_fields.append(rf)
body, content_type = encode_multipart_formdata(new_fields)
return body, content_type
class RequestHooksMixin(object):
def register_hook(self, event, hook):
"""Properly register a hook."""
if event not in self.hooks:
raise ValueError('Unsupported event specified, with event name "%s"' % (event))
if isinstance(hook, Callable):
self.hooks[event].append(hook)
elif hasattr(hook, '__iter__'):
self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
def deregister_hook(self, event, hook):
"""Deregister a previously registered hook.
Returns True if the hook existed, False if not.
"""
try:
self.hooks[event].remove(hook)
return True
except ValueError:
return False
class Request(RequestHooksMixin):
"""A user-created :class:`Request <Request>` object.
Used to prepare a :class:`PreparedRequest <PreparedRequest>`, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
<PreparedRequest [GET]>
"""
def __init__(self,
method=None, url=None, headers=None, files=None, data=None,
params=None, auth=None, cookies=None, hooks=None, json=None):
# Default empty dicts for dict params.
data = [] if data is None else data
files = [] if files is None else files
headers = {} if headers is None else headers
params = {} if params is None else params
hooks = {} if hooks is None else hooks
self.hooks = default_hooks()
for (k, v) in list(hooks.items()):
self.register_hook(event=k, hook=v)
self.method = method
self.url = url
self.headers = headers
self.files = files
self.data = data
self.json = json
self.params = params
self.auth = auth
self.cookies = cookies
def __repr__(self):
return '<Request [%s]>' % (self.method)
def prepare(self):
"""Constructs a :class:`PreparedRequest <PreparedRequest>` for transmission and returns it."""
p = PreparedRequest()
p.prepare(
method=self.method,
url=self.url,
headers=self.headers,
files=self.files,
data=self.data,
json=self.json,
params=self.params,
auth=self.auth,
cookies=self.cookies,
hooks=self.hooks,
)
return p
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
"""The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
containing the exact bytes that will be sent to the server.
Generated from either a :class:`Request <Request>` object or manually.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
<PreparedRequest [GET]>
>>> s = requests.Session()
>>> s.send(r)
<Response [200]>
"""
def __init__(self):
#: HTTP verb to send to the server.
self.method = None
#: HTTP URL to send the request to.
self.url = None
#: dictionary of HTTP headers.
self.headers = None
# The `CookieJar` used to create the Cookie header will be stored here
# after prepare_cookies is called
self._cookies = None
#: request body to send to the server.
self.body = None
#: dictionary of callback hooks, for internal usage.
self.hooks = default_hooks()
#: integer denoting starting position of a readable file-like body.
self._body_position = None
def prepare(self,
method=None, url=None, headers=None, files=None, data=None,
params=None, auth=None, cookies=None, hooks=None, json=None):
"""Prepares the entire request with the given parameters."""
self.prepare_method(method)
self.prepare_url(url, params)
self.prepare_headers(headers)
self.prepare_cookies(cookies)
self.prepare_body(data, files, json)
self.prepare_auth(auth, url)
# Note that prepare_auth must be last to enable authentication schemes
# such as OAuth to work on a fully prepared request.
# This MUST go after prepare_auth. Authenticators could add a hook
self.prepare_hooks(hooks)
def __repr__(self):
return '<PreparedRequest [%s]>' % (self.method)
def copy(self):
p = PreparedRequest()
p.method = self.method
p.url = self.url
p.headers = self.headers.copy() if self.headers is not None else None
p._cookies = _copy_cookie_jar(self._cookies)
p.body = self.body
p.hooks = self.hooks
p._body_position = self._body_position
return p
def prepare_method(self, method):
"""Prepares the given HTTP method."""
self.method = method
if self.method is not None:
self.method = to_native_string(self.method.upper())
@staticmethod
def _get_idna_encoded_host(host):
import idna
try:
host = idna.encode(host, uts46=True).decode('utf-8')
except idna.IDNAError:
raise UnicodeError
return host
def prepare_url(self, url, params):
"""Prepares the given HTTP URL."""
#: Accept objects that have string representations.
#: We're unable to blindly call unicode/str functions
#: as this will include the bytestring indicator (b'')
#: on python 3.x.
#: https://github.com/requests/requests/pull/2238
if isinstance(url, bytes):
url = url.decode('utf8')
else:
url = unicode(url) if is_py2 else str(url)
# Remove leading whitespaces from url
url = url.lstrip()
# Don't do any URL preparation for non-HTTP schemes like `mailto`,
# `data` etc to work around exceptions from `url_parse`, which
# handles RFC 3986 only.
if ':' in url and not url.lower().startswith('http'):
self.url = url
return
# Support for unicode domain names and paths.
try:
scheme, auth, host, port, path, query, fragment = parse_url(url)
except LocationParseError as e:
raise InvalidURL(*e.args)
if not scheme:
error = ("Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?")
error = error.format(to_native_string(url, 'utf8'))
raise MissingSchema(error)
if not host:
raise InvalidURL("Invalid URL %r: No host supplied" % url)
# In general, we want to try IDNA encoding the hostname if the string contains
# non-ASCII characters. This allows users to automatically get the correct IDNA
# behaviour. For strings containing only ASCII characters, we need to also verify
# it doesn't start with a wildcard (*), before allowing the unencoded hostname.
if not unicode_is_ascii(host):
try:
host = self._get_idna_encoded_host(host)
except UnicodeError:
raise InvalidURL('URL has an invalid label.')
elif host.startswith(u'*'):
raise InvalidURL('URL has an invalid label.')
# Carefully reconstruct the network location
netloc = auth or ''
if netloc:
netloc += '@'
netloc += host
if port:
netloc += ':' + str(port)
# Bare domains aren't valid URLs.
if not path:
path = '/'
if is_py2:
if isinstance(scheme, str):
scheme = scheme.encode('utf-8')
if isinstance(netloc, str):
netloc = netloc.encode('utf-8')
if isinstance(path, str):
path = path.encode('utf-8')
if isinstance(query, str):
query = query.encode('utf-8')
if isinstance(fragment, str):
fragment = fragment.encode('utf-8')
if isinstance(params, (str, bytes)):
params = to_native_string(params)
enc_params = self._encode_params(params)
if enc_params:
if query:
query = '%s&%s' % (query, enc_params)
else:
query = enc_params
url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
self.url = url
def prepare_headers(self, headers):
"""Prepares the given HTTP headers."""
self.headers = CaseInsensitiveDict()
if headers:
for header in headers.items():
# Raise exception on invalid header value.
check_header_validity(header)
name, value = header
self.headers[to_native_string(name)] = value
def prepare_body(self, data, files, json=None):
"""Prepares the given HTTP body data."""
# Check if file, fo, generator, iterator.
# If not, run through normal process.
# Nottin' on you.
body = None
content_type = None
if not data and json is not None:
# urllib3 requires a bytes-like body. Python 2's json.dumps
# provides this natively, but Python 3 gives a Unicode string.
content_type = 'application/json'
body = complexjson.dumps(json)
if not isinstance(body, bytes):
body = body.encode('utf-8')
is_stream = all([
hasattr(data, '__iter__'),
not isinstance(data, (basestring, list, tuple, Mapping))
])
try:
length = super_len(data)
except (TypeError, AttributeError, UnsupportedOperation):
length = None
if is_stream:
body = data
if getattr(body, 'tell', None) is not None:
# Record the current file position before reading.
# This will allow us to rewind a file in the event
# of a redirect.
try:
self._body_position = body.tell()
except (IOError, OSError):
# This differentiates from None, allowing us to catch
# a failed `tell()` later when trying to rewind the body
self._body_position = object()
if files:
raise NotImplementedError('Streamed bodies and files are mutually exclusive.')
if length:
self.headers['Content-Length'] = builtin_str(length)
else:
self.headers['Transfer-Encoding'] = 'chunked'
else:
# Multi-part file uploads.
if files:
(body, content_type) = self._encode_files(files, data)
else:
if data:
body = self._encode_params(data)
if isinstance(data, basestring) or hasattr(data, 'read'):
content_type = None
else:
content_type = 'application/x-www-form-urlencoded'
self.prepare_content_length(body)
# Add content-type if it wasn't explicitly provided.
if content_type and ('content-type' not in self.headers):
self.headers['Content-Type'] = content_type
self.body = body
def prepare_content_length(self, body):
"""Prepare Content-Length header based on request method and body"""
if body is not None:
length = super_len(body)
if length:
# If length exists, set it. Otherwise, we fallback
# to Transfer-Encoding: chunked.
self.headers['Content-Length'] = builtin_str(length)
elif self.method not in ('GET', 'HEAD') and self.headers.get('Content-Length') is None:
# Set Content-Length to 0 for methods that can have a body
# but don't provide one. (i.e. not GET or HEAD)
self.headers['Content-Length'] = '0'
def prepare_auth(self, auth, url=''):
"""Prepares the given HTTP auth data."""
# If no Auth is explicitly provided, extract it from the URL first.
if auth is None:
url_auth = get_auth_from_url(self.url)
auth = url_auth if any(url_auth) else None
if auth:
if isinstance(auth, tuple) and len(auth) == 2:
# special-case basic HTTP auth
auth = HTTPBasicAuth(*auth)
# Allow auth to make its changes.
r = auth(self)
# Update self to reflect the auth changes.
self.__dict__.update(r.__dict__)
# Recompute Content-Length
self.prepare_content_length(self.body)
def prepare_cookies(self, cookies):
"""Prepares the given HTTP cookie data.
This function eventually generates a ``Cookie`` header from the
given cookies using cookielib. Due to cookielib's design, the header
will not be regenerated if it already exists, meaning this function
can only be called once for the life of the
:class:`PreparedRequest <PreparedRequest>` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
"""
if isinstance(cookies, cookielib.CookieJar):
self._cookies = cookies
else:
self._cookies = cookiejar_from_dict(cookies)
cookie_header = get_cookie_header(self._cookies, self)
if cookie_header is not None:
self.headers['Cookie'] = cookie_header
def prepare_hooks(self, hooks):
"""Prepares the given hooks."""
# hooks can be passed as None to the prepare method and to this
# method. To prevent iterating over None, simply use an empty list
# if hooks is False-y
hooks = hooks or []
for event in hooks:
self.register_hook(event, hooks[event])
class Response(object):
"""The :class:`Response <Response>` object, which contains a
server's response to an HTTP request.
"""
__attrs__ = [
'_content', 'status_code', 'headers', 'url', 'history',
'encoding', 'reason', 'cookies', 'elapsed', 'request'
]
def __init__(self):
self._content = False
self._content_consumed = False
self._next = None
#: Integer Code of responded HTTP Status, e.g. 404 or 200.
self.status_code = None
#: Case-insensitive Dictionary of Response Headers.
#: For example, ``headers['content-encoding']`` will return the
#: value of a ``'Content-Encoding'`` response header.
self.headers = CaseInsensitiveDict()
#: File-like object representation of response (for advanced usage).
#: Use of ``raw`` requires that ``stream=True`` be set on the request.
# This requirement does not apply for use internally to Requests.
self.raw = None
#: Final URL location of Response.
self.url = None
#: Encoding to decode with when accessing r.text.
self.encoding = None
#: A list of :class:`Response <Response>` objects from
#: the history of the Request. Any redirect responses will end
#: up here. The list is sorted from the oldest to the most recent request.
self.history = []
#: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
self.reason = None
#: A CookieJar of Cookies the server sent back.
self.cookies = cookiejar_from_dict({})
#: The amount of time elapsed between sending the request
#: and the arrival of the response (as a timedelta).
#: This property specifically measures the time taken between sending
#: the first byte of the request and finishing parsing the headers. It
#: is therefore unaffected by consuming the response content or the
#: value of the ``stream`` keyword argument.
self.elapsed = datetime.timedelta(0)
#: The :class:`PreparedRequest <PreparedRequest>` object to which this
#: is a response.
self.request = None
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
def __getstate__(self):
# Consume everything; accessing the content attribute makes
# sure the content has been fully read.
if not self._content_consumed:
self.content
return {attr: getattr(self, attr, None) for attr in self.__attrs__}
def __setstate__(self, state):
for name, value in state.items():
setattr(self, name, value)
# pickled objects do not have .raw
setattr(self, '_content_consumed', True)
setattr(self, 'raw', None)
def __repr__(self):
return '<Response [%s]>' % (self.status_code)
def __bool__(self):
"""Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
return self.ok
def __nonzero__(self):
"""Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
return self.ok
def __iter__(self):
"""Allows you to use a response as an iterator."""
return self.iter_content(128)
@property
def ok(self):
"""Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
try:
self.raise_for_status()
except HTTPError:
return False
return True
@property
def is_redirect(self):
"""True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
"""
return ('location' in self.headers and self.status_code in REDIRECT_STATI)
@property
def is_permanent_redirect(self):
"""True if this Response one of the permanent versions of redirect."""
return ('location' in self.headers and self.status_code in (codes.moved_permanently, codes.permanent_redirect))
@property
def next(self):
"""Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
return self._next
@property
def apparent_encoding(self):
"""The apparent encoding, provided by the chardet library."""
return chardet.detect(self.content)['encoding']
def iter_content(self, chunk_size=1, decode_unicode=False):
"""Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
"""
def generate():
# Special case for urllib3.
if hasattr(self.raw, 'stream'):
try:
for chunk in self.raw.stream(chunk_size, decode_content=True):
yield chunk
except ProtocolError as e:
raise ChunkedEncodingError(e)
except DecodeError as e:
raise ContentDecodingError(e)
except ReadTimeoutError as e:
raise ConnectionError(e)
else:
# Standard file-like object.
while True:
chunk = self.raw.read(chunk_size)
if not chunk:
break
yield chunk
self._content_consumed = True
if self._content_consumed and isinstance(self._content, bool):
raise StreamConsumedError()
elif chunk_size is not None and not isinstance(chunk_size, int):
raise TypeError("chunk_size must be an int, it is instead a %s." % type(chunk_size))
# simulate reading small chunks of the content
reused_chunks = iter_slices(self._content, chunk_size)
stream_chunks = generate()
chunks = reused_chunks if self._content_consumed else stream_chunks
if decode_unicode:
chunks = stream_decode_response_unicode(chunks, self)
return chunks
def iter_lines(self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=None, delimiter=None):
"""Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
"""
pending = None
for chunk in self.iter_content(chunk_size=chunk_size, decode_unicode=decode_unicode):
if pending is not None:
chunk = pending + chunk
if delimiter:
lines = chunk.split(delimiter)
else:
lines = chunk.splitlines()
if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
pending = lines.pop()
else:
pending = None
for line in lines:
yield line
if pending is not None:
yield pending
@property
def content(self):
"""Content of the response, in bytes."""
if self._content is False:
# Read the contents.
if self._content_consumed:
raise RuntimeError(
'The content for this response was already consumed')
if self.status_code == 0 or self.raw is None:
self._content = None
else:
self._content = b''.join(self.iter_content(CONTENT_CHUNK_SIZE)) or b''
self._content_consumed = True
# don't need to release the connection; that's been handled by urllib3
# since we exhausted the data.
return self._content
@property
def text(self):
"""Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
"""
# Try charset from content-type
content = None
encoding = self.encoding
if not self.content:
return str('')
# Fallback to auto-detected encoding.
if self.encoding is None:
encoding = self.apparent_encoding
# Decode unicode from given encoding.
try:
content = str(self.content, encoding, errors='replace')
except (LookupError, TypeError):
# A LookupError is raised if the encoding was not found which could
# indicate a misspelling or similar mistake.
#
# A TypeError can be raised if encoding is None
#
# So we try blindly encoding.
content = str(self.content, errors='replace')
return content
def json(self, **kwargs):
r"""Returns the json-encoded content of a response, if any.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises ValueError: If the response body does not contain valid json.
"""
if not self.encoding and self.content and len(self.content) > 3:
# No encoding set. JSON RFC 4627 section 3 states we should expect
# UTF-8, -16 or -32. Detect which one to use; If the detection or
# decoding fails, fall back to `self.text` (using chardet to make
# a best guess).
encoding = guess_json_utf(self.content)
if encoding is not None:
try:
return complexjson.loads(
self.content.decode(encoding), **kwargs
)
except UnicodeDecodeError:
# Wrong UTF codec detected; usually because it's not UTF-8
# but some other 8-bit codec. This is an RFC violation,
# and the server didn't bother to tell us what codec *was*
# used.
pass
return complexjson.loads(self.text, **kwargs)
@property
def links(self):
"""Returns the parsed header links of the response, if any."""
header = self.headers.get('link')
# l = MultiDict()
l = {}
if header:
links = parse_header_links(header)
for link in links:
key = link.get('rel') or link.get('url')
l[key] = link
return l
def raise_for_status(self):
"""Raises stored :class:`HTTPError`, if one occurred."""
http_error_msg = ''
if isinstance(self.reason, bytes):
# We attempt to decode utf-8 first because some servers
# choose to localize their reason strings. If the string
# isn't utf-8, we fall back to iso-8859-1 for all other
# encodings. (See PR #3538)
try:
reason = self.reason.decode('utf-8')
except UnicodeDecodeError:
reason = self.reason.decode('iso-8859-1')
else:
reason = self.reason
if 400 <= self.status_code < 500:
http_error_msg = u'%s Client Error: %s for url: %s' % (self.status_code, reason, self.url)
elif 500 <= self.status_code < 600:
http_error_msg = u'%s Server Error: %s for url: %s' % (self.status_code, reason, self.url)
if http_error_msg:
raise HTTPError(http_error_msg, response=self)
def close(self):
"""Releases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
"""
if not self._content_consumed:
self.raw.close()
release_conn = getattr(self.raw, 'release_conn', None)
if release_conn is not None:
release_conn()
