U
|
I=®dï
ã @ 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 eBjCeBjDeBjEeBjFeBjGfZHdZIdZJdZKG dd deLZMG dd deLZNG dd deNZOG d d d eMeNZPG d d d eLZQdS ) 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}|rD| d¡ | |¡ d |¡S )zBuild the path URL to use.ú/ú?Ú )r( ÚurlÚpathÚappendÚqueryÚjoin)Úselfr7 Úpr8 r: © r> úRD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/requests/models.pyÚpath_url= 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) Ú
|
isinstancer* r+ Úhasattrr r/ r9 Úencoder) )ÚdataÚresultÚkÚvsÚvr> r> r? Ú_encode_paramsR 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 )ÚnamerH ÚfilenameÚheaders)Ú content_type)Ú
|
ValueErrorrE r/ r rF r+ r* r9 ÚdecoderG ÚtupleÚlistÚlenr Ú bytearrayrA r Úmake_multipartr )ÚfilesrH Ú
|
new_fieldsÚfieldsÚfieldÚvalrL rJ ÚftÚfhÚfnÚfpÚfdataÚrfÚbodyrS r> r> r? Ú _encode_filesm sT
|
|
|
|
ÿÿ
|
|
|
z"RequestEncodingMixin._encode_filesN)Ú__name__Ú
|
__module__Ú __qualname__Úpropertyr@ Ú staticmethodrM rg r> r> r> r? r3 < s
|
|
r3 c @ s e Zd Zdd Zdd ZdS )ÚRequestHooksMixinc C sZ || j krtd| t|tr2| j | |¡ n$t|drV| j | dd |D ¡ dS )zProperly register a hook.z1Unsupported event specified, with event name "%s"rB c s s | ]}t |tr|V qd S ©N)rE r$ )Ú.0Úhr> r> r? Ú <genexpr>¸ s
|
z2RequestHooksMixin.register_hook.<locals>.<genexpr>N)ÚhooksrT rE r$ r9 rF Ú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)rr ÚremoverT rt r> r> r? Úderegister_hookº s
|
z!RequestHooksMixin.deregister_hookN)rh ri rj rw ry r> r> r> r? rm ® s rm 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)ru rv )r rr rW Úitemsrw Úmethodr7 rR r[ rH r0 ÚparamsÚauthÚcookies) r< r| r7 rR r[ rH r} r~ r rr r0 rJ rL r> r> r? Ú__init__â s" zRequest.__init__c C s
|
d| j S )Nz<Request [%s]>©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 rR r[ rH r0 r} r~ r rr ) ÚPreparedRequestÚpreparer| r7 rR r[ rH r0 r} r~ r rr ©r< r= r> r> r? r
þ s ö zRequest.prepare)
|
NNNNNNNNNN)rh ri rj Ú__doc__r r r
r> r> r> r? rz Æ s þ
|
rz 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.
|
|
Generated from either a :class:`Request <Request>` object or manually.
|
|
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 rn )r| r7 rR Ú_cookiesrf r rr Ú_body_positionr r> r> r? r # 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 rR r[ rH r} r~ r rr r0 r> r> r? r
4 s
|
|
|
zPreparedRequest.preparec C s
|
d| j S )Nz<PreparedRequest [%s]>r r r> r> r? r F s zPreparedRequest.__repr__c C sX t }| j|_| j|_| jd k r*| j ¡ nd |_t| j|_| j|_| j|_| j |_ |S rn )
|
r r| r7 rR Úcopyr r rf rr r r r> r> r? r I 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 T s
|
z PreparedRequest.prepare_methodc C sD ddl m} z|j| dd d¡} W n |jk
|
r> tY nX | S )Nr )ÚidnaT)Úuts46rC )Ú pip._vendorr rG rU Ú IDNAErrorÚ UnicodeError)Úhostr r> r> r? Ú_get_idna_encoded_hostZ s
|
z&PreparedRequest._get_idna_encoded_hostc
|
C s, t |tr| d¡}ntr"t|nt|}| ¡ }d|krR| ¡ d¡sR|| _ dS zt
|
|\}}}}}}} W n, t k
|
r }
|
zt |
|
j W 5 d}
|
~
|
X Y nX |sºd} | t|d¡} t| |sÊt d| t|sz| |¡}W n tk
|
rþ t dY nX n| d¡rt d|p d } | r.| d
|
7 } | |7 } |rL| dt| 7 } |sVd }trÊt |trr| d ¡}t | tr| d ¡} t |tr| d ¡}t |tr´| d ¡}t | trÊ| d ¡} t |ttfrât|}| |¡} | r
|
|rd || f }n| }tt|| |d|| g}|| _ dS )z Prepares the given HTTP URL.Úutf8ú:ÚhttpNzDInvalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?z Invalid URL %r: No host suppliedzURL has an invalid label.Ú*r6 ú@r4 rC z%s&%s)rE r+ rU r, Úunicoder* ÚlstripÚlowerÚ
|
startswithr7 r r r ÚargsÚformatr r r r r rG rM r r' )r< r7 r} Úschemer~ r Úportr8 r: ÚfragmentÚeÚerrorÚnetlocÚ
|
enc_paramsr> r> r? r d sh
|
|
|
|
|
|
|
|
|
zPreparedRequest.prepare_urlc C s< t | _|r8| ¡ D ]"}t| |\}}|| jt|< qdS )z Prepares the given HTTP headers.N)r rR r{ r# r )r< rR ÚheaderrP Úvaluer> r> r? r º s z PreparedRequest.prepare_headersc
|
C sr d}d}|s6|dk r6d}t |¡}t|ts6| d¡}tt|dt|ttt t
|
f g}|røz t |}W n t t tfk
|
r d}Y nX |}t|dddk rÌz| ¡ | _W n ttfk
|
rÊ t | _Y nX |rØtd|rìt|| jd< n
|
d| jd < np|r| ||¡\}}n2|rB| |¡}t|ts8t|d
|
r>d}nd }| |¡ |rhd | jkrh|| jd < || _dS )z"Prepares the given HTTP body data.Nzapplication/jsonrC rB Útellz1Streamed bodies and files are mutually exclusive.úContent-LengthÚchunkedzTransfer-EncodingrA z!application/x-www-form-urlencodedz content-typez Content-Type) Ú complexjsonÚdumpsrE r+ rG ÚallrF r/ rW rV r% r" Ú TypeErrorÚAttributeErrorr Úgetattrr® r ÚIOErrorÚOSErrorÚobjectÚNotImplementedErrorr. rR rg rM Úprepare_content_lengthrf )r< rH r[ r0 rf rS Ú is_streamÚlengthr> r> r? r Å sL
|
|
|
þ
|
|
|
|
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)r" r. rR r| Úget)r< rf 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.NrN ) r r7 ÚanyrE rV rX r Ú__dict__Úupdater» rf )r< r~ r7 Úurl_authÚrr> r> r? r 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 rR )r< r Ú cookie_headerr> r> r? r - s
|
z PreparedRequest.prepare_cookiesc C s& |pg }|D ]}| ||| ¡ q dS )zPrepares the given hooks.N)rw )r< rr ru r> r> r? r A s z PreparedRequest.prepare_hooks)
|
NNNNNNNNNN)N)r6 )rh ri rj r r r
r r r rl r r r r r» r r r r> r> r> r? r s2 þ
|
|
V
|
E
|
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_coderR r7 ÚhistoryÚencodingÚreasonr ÚelapsedÚrequestc 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 rR Úrawr7 rÎ rÍ rÏ r r ÚdatetimeÚ timedeltarÐ rÑ r r> r> r? r U s
|
zResponse.__init__c C s | S rn r> r r> r> r? Ú __enter__ s zResponse.__enter__c G s | ¡ d S rn )Úclose)r< r£ r> r> r? Ú__exit__ s zResponse.__exit__c s j s j fdd jD S )Nc s i | ]}|t |d qS rn )r¶ )ro Ú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< ÚstaterP r r> r> r? Ú __setstate__ s zResponse.__setstate__c C s
|
d| j S )Nz<Response [%s]>)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)rR 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ê )rR rÌ r1 Ú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 )z7The apparent encoding, provided by the chardet library.rÎ )r- ÚdetectrÜ r r> r> r? Úapparent_encodingÕ s zResponse.apparent_encodingr
|
Fc s| fdd}j r(tjtr(t n" dk rJt tsJtdt tj }| }j rf|n|}|rxt |}|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ªz jj ddD ]
|
} | V q W qÄ tk
|
rV } z t|W 5 d }~X Y qÄ tk
|
r~ } z t|W 5 d }~X Y qÄ tk
|
r¦ } z t|W 5 d }~X Y qÄX nj ¡} | s¼qÄ| V qªd_
|
d S )NÚstreamT)Údecode_content) rF rÔ ró r r r r r r rA 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Ò 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 ]n}|dk r&|| }|r6| |¡}n| ¡ }|rl|d rl|rl|d d |d krl| ¡ }nd}|D ]
|
}|V qtq|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õ ÚlinesÚliner> r> r? Ú
|
iter_lines 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Ü 0 s
|
ÿzResponse.contentc C sh d}| j }| jstdS | j dkr(| j}zt| 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.
|
Nr6 Úreplace)Úerrors)rÎ rÜ r* rò Ú LookupErrorr´ )r< rÜ rÎ r> r> r? ÚtextD s
|
z Response.textc K sj | j sZ| jrZt| jdkrZt| j}|dk rZztj| j |¡f|W 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.
|
rO N) rÎ rÜ rX r! r± ÚloadsrU ÚUnicodeDecodeErrorr )r< ÚkwargsrÎ r> r> r? r0 j 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 )rR rÁ r )r< r¬ ÚlÚ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 rxn nd| j|| jf }n,d| j krdk r¤n nd| j|| jf }|r´t|| d d
|
S ) z+Raises :class:`HTTPError`, if one occurred.r6 rC z
|
iso-8859-1i iô z %s Client Error: %s for url: %siX z %s Server Error: %s for url: %s)ÚresponseN)rE rÏ r+ rU 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) rh ri rj r rÝ r r× rÙ rÞ rá r rå ræ rB rk rä rì rï rð rò rè ÚITER_CHUNK_SIZEr rÜ r r0 r ré rØ r> r> r> r? rÊ K sT þ/
|
|
|
|
|
|
|
|
7
|
|
%
|
rÊ )Rr rÕ ÚsysÚencodings.idnaÚ encodingsZpip._vendor.urllib3.fieldsr Z pip._vendor.urllib3.filepostr Úpip._vendor.urllib3.utilr Z pip._vendor.urllib3.exceptionsr r r r Úior rr r Ú
|
structuresr r~ r r r r r Ú
|
exceptionsr r r r r r r Ú_internal_utilsr r Úutilsr r r r r r r r! r" r# Úcompatr$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r± Ú status_codesr1 ÚmovedÚfoundÚotherÚtemporary_redirectrî rë ÚDEFAULT_REDIRECT_LIMITr r r¹ r3 rm rz r rÊ r> r> r> r? Ú<module> sD $08 ûrJ =
|
