U
|
¡ý°d ã @ sì d Z ddlZddlZddlmZ ddlmZmZm Z m
|
Z
|
m Z ddl m Z ddlmZ ddlmZ dd lmZmZ dd
|
lmZ dd lmZmZmZmZm Z m Z m Z dd lm Z dd lm!Z!m"Z"m#Z# ddl$m%Z%m&Z&m'Z' ddl(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. ddl(mZ/ ddl(m0Z0 ddl(m Z1 ddl(m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZC e6jDe6jEe6jFe6jGe6jHfZIdZJdZKdZLG dd d ZMG d d d ZNG d d d eNZOG d!d" d"eMeNZPG d#d$ d$ZQdS )%z`
|
requests.models
|
~~~~~~~~~~~~~~~
|
|
This module contains the primary objects that power Requests.
|
é N)ÚUnsupportedOperation)Ú DecodeErrorÚLocationParseErrorÚ ProtocolErrorÚReadTimeoutErrorÚSSLError)Ú RequestField)Úencode_multipart_formdata)Ú parse_urlé )Úto_native_stringÚunicode_is_ascii)Ú HTTPBasicAuth)ÚCallableÚJSONDecodeErrorÚMappingÚ
|
basestringÚ builtin_strÚchardetÚ cookielib)Újson)Ú urlencodeÚurlsplitÚ
|
urlunparse)Ú_copy_cookie_jarÚcookiejar_from_dictÚget_cookie_header)ÚChunkedEncodingErrorÚConnectionErrorÚContentDecodingErrorÚ HTTPErrorÚInvalidJSONErrorÚ
|
InvalidURL)r )Ú MissingSchema)r )ÚStreamConsumedError)Ú default_hooks)Úcodes)ÚCaseInsensitiveDict)
|
Úcheck_header_validityÚget_auth_from_urlÚguess_filenameÚguess_json_utfÚ iter_slicesÚparse_header_linksÚ requote_uriÚ stream_decode_response_unicodeÚ super_lenÚto_key_val_listé i ( i c @ s0 e Zd Zedd Zedd Zedd ZdS )ÚRequestEncodingMixinc C sN g }t | j}|j}|s d}| |¡ |j}|rD| d¡ | |¡ d |¡S )zBuild the path URL to use.ú/ú?Ú )r ÚurlÚpathÚappendÚqueryÚjoin)Úselfr7 Úpr8 r: © r> úFd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\requests/models.pyÚpath_urlU s
|
|
|
|
z RequestEncodingMixin.path_urlc C s¶ t | ttfr| S t| dr | S t| dr®g }t| D ]j\}}t |tsRt|dsX|g}|D ]B}|dk r\| t |tr| d¡n|t |tr| d¡n|f¡ q\q6t|ddS | 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__Núutf-8T)Údoseq) Ú
|
isinstanceÚstrÚbytesÚhasattrr1 r r9 Úencoder )ÚdataÚresultÚkÚvsÚvr> r> r? Ú_encode_paramsj s$
|
|
þÿ z#RequestEncodingMixin._encode_paramsc C s® | st dnt|tr t dg }t|p,i }t| p8i } |D ]|\}}t|ts\t|dsb|g}|D ]T}|dk rft|tst|}| t|tr| d¡n|t|tr²| d¡n|f¡ qfq@| D ]Ö\}}d}d} t|t
|
t fr t |dkrø|\}
|
} n&t |dkr|\}
|
} }n |\}
|
} }} nt |p,|}
|
|} t| tttfrJ| } n(t| dr`| ¡ } n| dkrnqÂn| } t|| |
|
| d } | j|d
|
| | ¡ qÂ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.rB NrC é é rA )ÚnamerJ ÚfilenameÚheaders)Ú content_type)Ú
|
ValueErrorrE r r1 rH rG rF r9 ÚdecoderI ÚtupleÚlistÚlenr* Ú bytearrayrA r Úmake_multipartr )ÚfilesrJ Ú
|
new_fieldsÚfieldsÚfieldÚvalrN rL ÚftÚfhÚfnÚfpÚfdataÚrfÚbodyrU r> r> r? Ú _encode_files sX
|
|
|
|
ÿ üÿ
|
|
|
z"RequestEncodingMixin._encode_filesN)Ú__name__Ú
|
__module__Ú __qualname__Úpropertyr@ Ú staticmethodrO ri r> r> r> r? r3 T s
|
|
r3 c @ s e Zd Zdd Zdd ZdS )ÚRequestHooksMixinc C s^ || j krtd| dt|tr6| j | |¡ n$t|drZ| j | dd |D ¡ dS )zProperly register a hook.z.Unsupported event specified, with event name "ú"rB c s s | ]}t |tr|V qd S ©N)rE r )Ú.0Úhr> r> r? Ú <genexpr>Ø s
|
z2RequestHooksMixin.register_hook.<locals>.<genexpr>N)ÚhooksrV rE r r9 rH Úextend©r< ÚeventÚhookr> r> r? Ú register_hookÏ s
|
|
|
z RequestHooksMixin.register_hookc C s2 z| j | |¡ W dS tk
|
r, Y dS X dS )ziDeregister a previously registered hook.
|
Returns True if the hook existed, False if not.
|
TFN)ru ÚremoverV rw r> r> r? Úderegister_hookÚ s
|
z!RequestHooksMixin.deregister_hookN)rj rk rl rz r| r> r> r> r? ro Î s ro c
|
@ s* e Zd ZdZd ddZdd 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 | _t| ¡ D ]\} } | j| | d qd|| _|| _|| _|| _|| _ |
|
| _
|
|| _ || _ || _ d S )N)rx ry )r% ru rY Úitemsrz Úmethodr7 rT r] rJ r ÚparamsÚauthÚcookies) r< r r7 rT r] rJ r r r ru r rL rN r> r> r? Ú__init__ s" zRequest.__init__c C s d| j dS )Nz
|
<Request [ú]>©r ©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.)
|
r r7 rT r] rJ r r r r ru ) ÚPreparedRequestÚpreparer r7 rT r] rJ r r r r ru ©r< r= r> r> r? r ( s ö zRequest.prepare)
|
NNNNNNNNNN)rj rk rl Ú__doc__r r r r> r> r> r? r} æ s õ
|
#r} c
|
@ s e Zd ZdZdd Zd ddZdd Zd d
|
Zd d Ze d d Z
|
dd Z dd Z d ddZ dd Zd ddZdd Zd d ZdS )!r a) The fully mutable :class:`PreparedRequest <PreparedRequest>` object,
|
containing the exact bytes that will be sent to the server.
|
|
Instances are generated from a :class:`Request <Request>` object, and
|
should not be instantiated manually; doing so may produce undesirable
|
effects.
|
|
Usage::
|
|
>>> import requests
|
>>> req = requests.Request('GET', 'https://httpbin.org/get')
|
>>> r = req.prepare()
|
>>> r
|
<PreparedRequest [GET]>
|
|
>>> s = requests.Session()
|
>>> s.send(r)
|
<Response [200]>
|
c C s0 d | _ d | _d | _d | _d | _t | _d | _d S rq )r r7 rT Ú_cookiesrh r% ru Ú_body_positionr r> r> r? r O s zPreparedRequest.__init__Nc C sR | |¡ | ||¡ | |¡ | |¡ | |||
|
¡ | ||¡ | | ¡ 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< r r7 rT r] rJ r r r ru r r> r> r? r ` s
|
|
|
zPreparedRequest.preparec C s d| j dS )Nz<PreparedRequest [r r
r r> r> r? r | s zPreparedRequest.__repr__c C sX t }| j|_| j|_| jd k r*| j ¡ nd |_t| j|_| j|_| j|_| j |_ |S rq )
|
r r r7 rT Úcopyr r rh ru r r r> r> r? r s zPreparedRequest.copyc C s$ || _ | j dk r t| j ¡ | _ dS )z Prepares the given HTTP method.N)r r Úupper)r< r r> r> r? r s
|
z PreparedRequest.prepare_methodc C s@ dd l }z|j| dd d¡} W n |jk
|
r: tY nX | S )Nr T)Úuts46rC )ÚidnarI rW Ú IDNAErrorÚ UnicodeError)Úhostr r> r> r? Ú_get_idna_encoded_host s
|
z&PreparedRequest._get_idna_encoded_hostc
|
C s¨ t |tr| d¡}nt|}| ¡ }d|krF| ¡ d¡sF|| _dS zt|\}}}}}}} W n, t k
|
r }
|
zt
|
|
|
j W 5 d}
|
~
|
X Y nX |s¨t d|d| d|s¼t
|
d|dt |sòz| |¡}W n tk
|
rî t
|
d Y nX n| d
|
¡rt
|
d |pd } | r | d 7 } | |7 } |r:| d| 7 } |sDd }t |ttfr\t|}| |¡} | r|r| d| }n| }tt|| |d|| g}|| _dS )z Prepares the given HTTP URL.Úutf8ú:ÚhttpNz Invalid URL z0: No scheme supplied. Perhaps you meant https://r5 z: No host suppliedzURL has an invalid label.)Ú*Ú.r6 ú@r4 ú&)rE rG rW rF ÚlstripÚlowerÚ
|
startswithr7 r
|
r r" Úargsr# r r r r rO r. r ) r< r7 r Úschemer r Úportr8 r: ÚfragmentÚeÚnetlocÚ
|
enc_paramsr> r> r? r sR
|
ÿ
|
|
zPreparedRequest.prepare_urlc C s< t | _|r8| ¡ D ]"}t| |\}}|| jt|< qdS )z Prepares the given HTTP headers.N)r' rT r~ r( r )r< rT ÚheaderrR Úvaluer> r> r? r ä s z PreparedRequest.prepare_headersc
|
C s° d}d}|sn|dk rnd}zt j|dd}W n. tk
|
rX } zt|| dW 5 d}~X Y nX t|tsn| d¡}tt|dt|t t
|
t t f g}|r6z t |}W n tttfk
|
rÀ d}Y nX |}t|dddk rz| ¡ | _W n tk
|
r t | _Y nX |rtd |r*t|| jd
|
< n
|
d | jd < np|rN| ||¡\}}n2|r| |¡}t|t svt|d r|d}nd}| |¡ |r¦d| jkr¦|| jd< || _ dS )z"Prepares the given HTTP body data.Nzapplication/jsonF)Ú allow_nan)ÚrequestrC rB Útellz1Streamed bodies and files are mutually exclusive.úContent-LengthÚchunkedzTransfer-EncodingrA z!application/x-www-form-urlencodedz content-typez Content-Type) Ú complexjsonÚdumpsrV r! rE rG rI ÚallrH r rY rX r r0 Ú TypeErrorÚAttributeErrorr Úgetattrr² r ÚOSErrorÚobjectÚNotImplementedErrorr rT ri rO Úprepare_content_lengthrh ) r< rJ r] r rh rU ÚveÚ is_streamÚlengthr> r> r? r ï sX
|
|
þÿ
|
ÿ
|
|
|
z PreparedRequest.prepare_bodyc C sL |dk r$t |}|rHt|| jd< n$| jdkrH| j d¡dkrHd| jd< dS )z>Prepare Content-Length header based on request method and bodyNr³ )ÚGETÚHEADÚ0)r0 r rT r Úget)r< rh rÁ r> r> r? r¾ = s ÿþz&PreparedRequest.prepare_content_lengthr6 c C sj |dkr"t | j}t|r |nd}|rft|trDt|dkrDt| }|| }| j |j¡ | | j
|
¡ dS )z"Prepares the given HTTP auth data.NrP ) r) r7 ÚanyrE rX rZ r Ú__dict__Úupdater¾ rh )r< r r7 Úurl_authÚrr> r> r? r M s
|
z PreparedRequest.prepare_authc C s@ t |tjr|| _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.
|
NÚCookie)rE r Ú CookieJarr r r rT )r< r Ú cookie_headerr> r> r? r c s
|
z PreparedRequest.prepare_cookiesc C s& |pg }|D ]}| ||| ¡ q dS )zPrepares the given hooks.N)rz )r< ru rx r> r> r? r w s z PreparedRequest.prepare_hooks)
|
NNNNNNNNNN)N)r6 )rj rk rl r r r r r r rn r r r r r¾ r r r r> r> r> r? r : s2 õ
|
|
J
|
N
|
r 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_coderT r7 ÚhistoryÚencodingÚreasonr Úelapsedr± c C s^ d| _ d| _d | _d | _t | _d | _d | _d | _g | _ d | _
|
t i | _ t d¡| _d | _d S )NFr )rÏ Ú_content_consumedÚ_nextrÐ r' rT Úrawr7 rÒ rÑ rÓ r r ÚdatetimeÚ timedeltarÔ r± r r> r> r? r s
|
zResponse.__init__c C s | S rq r> r r> r> r? Ú __enter__Â s zResponse.__enter__c G s | ¡ d S rq )Úclose)r< r§ r> r> r? Ú__exit__Å s zResponse.__exit__c s j s j fdd jD S )Nc s i | ]}|t |d qS rq )rº )rr Úattrr r> r? Ú
|
<dictcomp>Î s z)Response.__getstate__.<locals>.<dictcomp>)rÕ ÚcontentÚ __attrs__r r> r r? Ú __getstate__È s zResponse.__getstate__c C s: | ¡ D ]\}}t| || qt| dd t| dd d S )NrÕ Tr× )r~ Úsetattr)r< ÚstaterR r¯ r> r> r? Ú __setstate__Ð s zResponse.__setstate__c C s d| j dS )Nz <Response [r )rÐ r r> r> r? r Ø 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``.
|
©Úokr r> r> r? Ú__bool__Û s zResponse.__bool__c C s | j S rå ræ r r> r> r? Ú __nonzero__å s zResponse.__nonzero__c C s
|
| d¡S )z,Allows you to use a response as an iterator.é )Ú iter_contentr r> r> r? rB ï s zResponse.__iter__c C s( z | ¡ W n tk
|
r" Y 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 )zTrue if this Response is a well-formed HTTP redirect that could have
|
been processed automatically (by :meth:`Session.resolve_redirects`).
|
Úlocation)rT rÐ ÚREDIRECT_STATIr 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í )rT rÐ r& Úmoved_permanentlyÚpermanent_redirectr 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¡d S )zOThe apparent encoding, provided by the charset_normalizer or chardet libraries.rÒ )r Údetectrß r r> r> r? Úapparent_encoding s zResponse.apparent_encodingr Fc s fdd}j r(tjtr(t n& dk rNt tsNtdt dtj }| }j rj|n|}|r|t |}|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 jdrÌzjj ddE d H W qæ tk
|
rP } z t| W 5 d } ~ X Y qæ tk
|
rx } z t| W 5 d } ~ X Y qæ tk
|
r } z t| W 5 d } ~ X Y qæ t k
|
rÈ } z t
|
| W 5 d } ~ X Y qæX nj ¡}|sÞqæ|V qÌd_ d S )NÚstreamT)Údecode_content) rH r× rö r r r r r r r ÚRequestsSSLErrorrA rÕ )r« Úchunk©Ú
|
chunk_sizer< r> r? Úgenerate, s z'Response.iter_content.<locals>.generateNz+chunk_size must be an int, it is instead a r¡ )
|
rÕ rE rÏ Úboolr$ Úintr¸ Útyper, r/ )r< rû Údecode_unicoderü Ú reused_chunksÚ stream_chunksÚchunksr> rú r? rë s ÿ
|
zResponse.iter_contentNc c s d}| j ||dD ]h}|dk r&|| }|r6| |¡}n| ¡ }|rl|d rl|rl|d d |d krl| ¡ }nd}|E dH q|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ë ÚsplitÚ
|
splitlinesÚpop)r< rû r Ú delimiterÚpendingrù Úlinesr> r> r? Ú
|
iter_linesU s
|
ÿ
|
$
|
zResponse.iter_linesc C sV | j dkrJ| jrtd| jdks,| jdkr4d| _ nd | t¡¡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_SIZEr r> r> r? rß w s
|
zResponse.contentc C sd d}| j }| jsdS | j dkr$| j}zt| j|dd}W n& ttfk
|
r^ t| jdd}Y nX |S )aÚ Content of the response, in unicode.
|
|
If Response.encoding is None, encoding will be guessed using
|
``charset_normalizer`` or ``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.
|
Nr6 Úreplace)Úerrors)rÒ rß rõ rF Ú LookupErrorr¸ )r< rß rÒ r> r> r? Útext s
|
z Response.textc
|
K sØ | j s| jrt| jdkrt| j}|dk rztj| j |¡f|W S tk
|
rX Y n4 tk
|
r } zt |j
|
|j |j W 5 d}~X Y nX ztj| j f|W S tk
|
rÒ } zt |j
|
|j |j W 5 d}~X Y nX dS )zýReturns the json-encoded content of a response, if any.
|
|
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
|
:raises requests.exceptions.JSONDecodeError: If the response body does not
|
contain valid json.
|
rQ N)rÒ rß rZ r+ rµ ÚloadsrW ÚUnicodeDecodeErrorr ÚRequestsJSONDecodeErrorÚmsgÚdocÚposr )r< ÚkwargsrÒ r« r> r> r? r ° s
|
$z Response.jsonc C sF | j d¡}i }|rBt|}|D ] }| d¡p6| d¡}|||< q |S )z8Returns the parsed header links of the response, if any.ÚlinkÚrelr7 )rT rÅ r- )r< r® Zresolved_linksÚlinksr Úkeyr> r> r? r Ñ s
|
zResponse.linksc C sÄ d}t | jtrDz| j d¡}W qJ tk
|
r@ | j d¡}Y qJX n| j}d| j kr`dk r~n n| j d| d| j }n2d| j krdk r°n n| j d | d| j }|rÀt|| d
|
d S ) z+Raises :class:`HTTPError`, if one occurred.r6 rC z
|
iso-8859-1i iô z Client Error: z
|
for url: iX z Server Error: )ÚresponseN)rE rÓ rG rW r rÐ r7 r )r< Úhttp_error_msgrÓ r> r> r? rì â s ÿÿzResponse.raise_for_statusc C s0 | j s| j ¡ 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) rj rk rl r rà r rÚ rÜ rá rä r rè ré rB rm rç rï rò ró rõ rë ÚITER_CHUNK_SIZEr rß r r r rì rÛ r> r> r> r? rÎ sZ ö /
|
|
|
|
|
|
|
|
; ÿ
|
"
|
|
%!
|
rÎ )Rr rØ Úencodings.idnaÚ encodingsÚior Zurllib3.exceptionsr r r r r Zurllib3.fieldsr Zurllib3.filepostr Z urllib3.utilr
|
Ú_internal_utilsr r r r Úcompatr r r r r r r r rµ r r r r r r r Ú
|
exceptionsr r r r r! r" r r# rø r$ ru r% Ú status_codesr& Ú
|
structuresr' Úutilsr( r) r* r+ r, r- r. r/ r0 r1 ÚmovedÚfoundÚotherÚtemporary_redirectrñ rî ÚDEFAULT_REDIRECT_LIMITr r! r3 ro r} r rÎ r> r> r> r? Ú<module> sL $ 0ûzT I
|
