U
|
ý°dz ã
|
@ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
|
Z
|
d dl Z d dl m Z d dlmZ d dlmZ d dlmZ z.z d dlZW n ek
|
r® d dlZY nX W n ek
|
rÊ dZY nX z:d dlZee e e dej ¡ ¡ Z!Z!e!dk rdZW n e"ee#fk
|
r& dZY nX d d
|
l$m%Z% d d l&m'Z' d d l(m)Z) d d l*m+Z+m,Z,m-Z- d dl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z:m;Z; d dl<m=Z= e j>rÌd dl?m@Z@ d dlAmBZB e CeD¡ZEG dd dZFG dd deFZGG dd dZHG dd deFZIedk r,G dd d eFZJedk rFG d d d eFZKG d d d eFZLd!dd"d#d$ZMG d%d& d&ZNG d'd( d(ejOZPG d)d* d*ePZdS )+é )Ú annotationsN)Úcontextmanager)Ú HTTPMessage)Ú HTTPResponse)Útimeoutz^([0-9]+)\.([0-9]+))r é é )Úutil)Ú
|
_TYPE_BODY)ÚHTTPHeaderDict)Ú BaseSSLErrorÚHTTPConnectionÚ HTTPException)
|
ÚBodyNotHttplibCompatibleÚ DecodeErrorÚ HTTPErrorÚIncompleteReadÚInvalidChunkLengthÚ InvalidHeaderÚ ProtocolErrorÚReadTimeoutErrorÚResponseNotChunkedÚSSLError)Ú is_fp_closedÚis_response_to_head)ÚRetry)ÚLiteral)ÚHTTPConnectionPoolc @ s* e Zd ZdddddZddddZdS ) ÚContentDecoderÚbytes©ÚdataÚreturnc C s
|
t d S ©N©ÚNotImplementedError©Úselfr! © r( úGd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\urllib3/response.pyÚ
|
decompressE s zContentDecoder.decompress©r" c C s
|
t d S r# r$ ©r' r( r( r) ÚflushH s zContentDecoder.flushN)Ú__name__Ú
|
__module__Ú __qualname__r* r- r( r( r( r) r D s r c @ s8 e Zd ZddddZdddddZddd d
|
Zd S ) ÚDeflateDecoderÚNoner+ c C s d| _ d| _t ¡ | _d S )NTó )Ú
|
_first_tryÚ_dataÚzlibÚ decompressobjÚ_objr, r( r( r) Ú__init__M s zDeflateDecoder.__init__r r c C s |s|S | j s| j |¡S | j|7 _z"| j |¡}|rFd| _ d | _|W S tjk
|
r d| _ t tj ¡| _z| | j¡W ¢ Y S d | _X Y nX d S )NF)r4 r8 r* r5 r6 Úerrorr7 Ú MAX_WBITS)r' r! Ú decompressedr( r( r) r* R s" zDeflateDecoder.decompressc C s
|
| j ¡ S r# ©r8 r- r, r( r( r) r- h s zDeflateDecoder.flushN©r. r/ r0 r9 r* r- r( r( r( r) r1 L s r1 c @ s e Zd ZdZdZdZdS )ÚGzipDecoderStater r é N)r. r/ r0 Ú FIRST_MEMBERÚ OTHER_MEMBERSÚ SWALLOW_DATAr( r( r( r) r? l s r? c @ s8 e Zd ZddddZdddddZddd d
|
Zd S ) Ú GzipDecoderr2 r+ c C s t dt j ¡| _tj| _d S ©Né )r6 r7 r; r8 r? rA Ú_stater, r( r( r) r9 s s zGzipDecoder.__init__r r c C s¤ t }| jtjks|s t|S z|| j |¡7 }W n< tjk
|
rn | j}tj| _|tj krht| Y S Y nX | jj
|
}|st|S tj | _t dtj ¡| _q d S rE ) Ú bytearrayrG r? rC r r8 r* r6 r: rB Ú unused_datar7 r; )r' r! ÚretÚprevious_stater( r( r) r* w s
|
zGzipDecoder.decompressc C s
|
| j ¡ S r# r= r, r( r( r) r- s zGzipDecoder.flushNr> r( r( r( r) rD r s rD c @ s( e Zd ZddddZddddZdS ) Ú BrotliDecoderr2 r+ c C s< t ¡ | _t| jdr(t| d| jj nt| d| jj d S )Nr* )ÚbrotliZ Decompressorr8 ÚhasattrÚsetattrr* Úprocessr, r( r( r) r9 s
|
zBrotliDecoder.__init__r c C s t | jdr| j ¡ S dS )Nr- r3 )rN r8 r- r, r( r( r) r- s
|
zBrotliDecoder.flushN)r. r/ r0 r9 r- r( r( r( r) rL s rL c @ s8 e Zd ZddddZdddddZddd d
|
Zd S ) Ú ZstdDecoderr2 r+ c C s t ¡ ¡ | _d S r# )ÚzstdZZstdDecompressorr7 r8 r, r( r( r) r9 ¦ s zZstdDecoder.__init__r r c C s |sdS | j |¡S )Nr3 )r8 r* r& r( r( r) r* © s zZstdDecoder.decompressc C s | j ¡ }| j jstd|S )Nz Zstandard data is incomplete)r8 r- Úeofr )r' rJ r( r( r) r- ® s
|
zZstdDecoder.flushNr> r( r( r( r) rQ ¥ s rQ c @ s> e Zd ZdZdddddZddd d
|
Zddd d d ZdS )Ú MultiDecodera
|
From RFC7231:
|
If one or more encodings have been applied to a representation, the
|
sender that applied the encodings MUST generate a Content-Encoding
|
header field that lists the content codings in the order in which
|
they were applied.
|
Ústrr2 )Úmodesr" c C s dd | d¡D | _d S )Nc S s g | ]}t | ¡ qS r( )Ú _get_decoderÚstrip)Ú.0Úmr( r( r) Ú
|
<listcomp>¿ s z)MultiDecoder.__init__.<locals>.<listcomp>ú,)ÚsplitÚ _decoders)r' rV r( r( r) r9 ¾ s zMultiDecoder.__init__r r+ c C s | j d ¡ S ©Nr )r^ r- r, r( r( r) r- Á s zMultiDecoder.flushr c C s t | jD ]}| |¡}q
|
|S r# )Úreversedr^ r* )r' r! Údr( r( r) r* Ä s zMultiDecoder.decompressN)r. r/ r0 Ú__doc__r9 r- r* r( r( r( r) rT µ s rT rU )Úmoder" c C sP d| krt | S | dkr t S td k r4| dkr4t S td k rJ| dkrJt S t S )Nr\ ÚgzipÚbrrR )rT rD rM rL rR rQ r1 )rc r( r( r) rW Ê s rW c @ sL e Zd ZdZddddZddddZd dd
|
d d Zdd d ddZdS )ÚBytesQueueBuffera Memory-efficient bytes buffer
|
|
To return decoded data in read() and still follow the BufferedIOBase API, we need a
|
buffer to always return the correct amount of bytes.
|
|
This buffer should be filled using calls to put()
|
|
Our maximum memory usage is determined by the sum of the size of:
|
|
* self.buffer, which contains the full data
|
* the largest chunk that we will copy in get()
|
|
The worst case scenario is a single chunk, in which case we'll make a full copy of
|
the data inside get().
|
r2 r+ c C s t ¡ | _d| _d S r_ )Ú collectionsÚdequeÚbufferÚ_sizer, r( r( r) r9 ë s
|
zBytesQueueBuffer.__init__Úintc C s | j S r# )rj r, r( r( r) Ú__len__ï s zBytesQueueBuffer.__len__r r c C s" | j |¡ | jt|7 _d S r# )ri Úappendrj Úlenr& r( r( r) Úputò s zBytesQueueBuffer.put)Únr" c C sÖ |dkr dS | j s tdn|dk r,tdd}t ¡ }||k rÎ|| }| j ¡ }t|}||k r¤|d |
||d
}}| |¡ | j |¡ | j |8 _ qÎn| |¡ | j |8 _ ||7 }| j s8qÎq8|
|
¡ S )Nr r3 zbuffer is emptyzn should be > 0) ri Ú RuntimeErrorÚ
|
ValueErrorÚioÚBytesIOÚpopleftrn ÚwriteÚ
|
appendleftrj Úgetvalue) r' rp ZfetchedrJ Ú remainingÚchunkZ chunk_lengthZ
|
left_chunkZ right_chunkr( r( r) Úgetö s0
|
|
|
|
zBytesQueueBuffer.getN)r. r/ r0 rb r9 rl ro r{ r( r( r( r) rf Ú s
|
rf c
|
@ s e Zd ZU ddgZedk r$edg7 Zedk r6edg7 Zdddd d
|
gZeej fZ
|
d e d < edk rje
|
ej f7 Z
|
edk r~e
|
ej f7 Z
|
ddd dddddddddddZ ddddZeddd d Zd dd d Zeddd!d"Zejddd#d$d"Zed%dd&d'Zeddd(d)Zejddd*d+d)ZdUd-d.d/d0d1d2ZdVd-d.ddd4d5d6ZdWd-d.d/d0d7d8Zddd9d:Zddd;d<Zddd=d>Zddd?d@Z dd.dddAdBdCZ dddDdEZ dFddGdHdIZ dJddKdLZ dXdMdddNdOdPZ!dJddQdRZ"dddSdTZ#dS )YÚBaseHTTPResponserd ÚdeflateNre rR i- i. i/ i3 i4 ztuple[type[Exception], ...]ÚDECODER_ERROR_CLASSES)ÚheadersÚretriesú>typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | Nonerk ú
|
str | NoneÚboolú Retry | Noner2 )r ÚstatusÚversionÚreasonÚdecode_contentÚ request_urlr r" c
|
C s t |tr|| _n
|
t|| _|| _|| _|| _|| _d| _|| _|| _ d| _
|
| j dd¡ ¡ }dd | d¡D } d| krd| _
|
d | _d S ) NFztransfer-encodingÚ c s s | ]}| ¡ V qd S r# )rX )rY Úencr( r( r) Ú <genexpr>> s z,BaseHTTPResponse.__init__.<locals>.<genexpr>r\ ÚchunkedT)Ú
|
isinstancer r r
r r r Ú_has_decoded_contentÚ _request_urlr r r{ Úlowerr] Ú_decoder)
|
r' r r
r r r r r Útr_encÚ encodingsr( r( r) r9 $ s
|
|
zBaseHTTPResponse.__init__zstr | None | Literal[False]r+ c C s | j | jkr| j d¡S dS )a
|
Should we redirect and where to?
|
|
:returns: Truthy redirect location string if we got a redirect status
|
code and valid location. ``None`` if redirect status and no
|
location. ``False`` if not a redirect status code.
|
ÚlocationF)r
ÚREDIRECT_STATUSESr r{ r, r( r( r) Úget_redirect_locationD s z&BaseHTTPResponse.get_redirect_locationr c C s
|
t d S r# r$ r, r( r( r) r! P s zBaseHTTPResponse.dataz
|
typing.Anyc C s | j d¡}t |¡S )a
|
Parses the body of the HTTP response as JSON.
|
|
To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to the decoder.
|
|
This method can raise either `UnicodeDecodeError` or `json.JSONDecodeError`.
|
|
Read more :ref:`here <json>`.
|
zutf-8)r! ÚdecodeÚ_jsonÚloadsr& r( r( r) ÚjsonT s
|
zBaseHTTPResponse.jsonc C s
|
t d S r# r$ r, r( r( r) Úurla s zBaseHTTPResponse.url©r r" c C s
|
t d S r# r$ ©r' r r( r( r) r e s úHTTPConnection | Nonec C s
|
t d S r# r$ r, r( r( r) Ú
|
connectioni s zBaseHTTPResponse.connectionc C s | j S r# )Ú_retriesr, r( r( r) r m s zBaseHTTPResponse.retries)r r" c C s& |d k r |j r |j d j| _|| _d S )Néÿÿÿÿ)ÚhistoryÚredirect_locationr r¡ )r' r r( r( r) r q s é ú
|
int | Noneú bool | Noneútyping.Iterator[bytes]©Úamtr r" c C s
|
t d S r# r$ ©r' rª r r( r( r) Ústreamx s zBaseHTTPResponse.streamF©rª r Ú cache_contentr" c C s
|
t d S r# r$ )r' rª r r® r( r( r) Úread} s zBaseHTTPResponse.readc C s
|
t d S r# r$ r« r( r( r) Ú read_chunked
s z BaseHTTPResponse.read_chunkedc C s
|
t d S r# r$ r, r( r( r) Ú release_conn s z BaseHTTPResponse.release_connc C s
|
t d S r# r$ r, r( r( r) Ú
|
drain_conn s zBaseHTTPResponse.drain_connc C s
|
t d S r# r$ r, r( r( r) Úclose s zBaseHTTPResponse.closec sd j dd¡ ¡ } jdkr`| jkr2t| _n.d|kr` fdd| d¡D }|r`t| _dS )z=
|
Set-up the _decoder attribute if necessary.
|
úcontent-encodingr Nr\ c s" g | ]}| ¡ jkr| ¡ qS r( )rX ÚCONTENT_DECODERS)rY Úer, r( r) r[ s þz2BaseHTTPResponse._init_decoder.<locals>.<listcomp>)r r{ r r rµ rW r] )r' Úcontent_encodingr r( r, r) Ú _init_decoder s
|
|
|
þz BaseHTTPResponse._init_decoder)r! r Ú flush_decoderr" c
|
C s |s| j rtd|S z | jr0| j |¡}d| _ W nF | jk
|
rx } z&| j dd¡ ¡ }td| ||W 5 d}~X Y nX |r|| ¡ 7 }|S )zN
|
Decode the data passed in and potentially flush the decoder.
|
ú_Calling read(decode_content=False) is not supported after read(decode_content=True) was called.Tr´ r zEReceived response with content-encoding: %s, but failed to decode it.N)
|
r rq r r* r~ r r{ r r Ú_flush_decoder)r' r! r r¹ r¶ r· r( r( r) Ú_decode¨ s. ÿ
|
ÿýü zBaseHTTPResponse._decodec C s | j r | j d¡| j ¡ S dS )zk
|
Flushes the decoder. Should only be called if the decoder is actually
|
being used.
|
r3 )r r* r- r, r( r( r) r» Æ s z BaseHTTPResponse._flush_decoderrH )Úbr" c C s: | t|¡}t|dkr dS ||d t|
< t|S d S r_ )r¯ rn )r' r½ Útempr( r( r) ÚreadintoÐ s
|
zBaseHTTPResponse.readintor c C s t jdtdd | jS )Nz|HTTPResponse.getheaders() is deprecated and will be removed in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.r@ ©ÚcategoryÚ
|
stacklevel)ÚwarningsÚwarnÚDeprecationWarningr r, r( r( r) Ú
|
getheadersÙ s üzBaseHTTPResponse.getheadersrU )ÚnameÚdefaultr" c C s t jdtdd | j ||¡S )NzHTTPResponse.getheader() is deprecated and will be removed in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).r@ rÀ )rà rÄ rÅ r r{ )r' rÇ rÈ r( r( r) Ú getheaderâ s üzBaseHTTPResponse.getheaderc C s | j S r# )r r, r( r( r) Úinfoì s zBaseHTTPResponse.infoc C s | j S r# )r r, r( r( r) Úgeturlï s zBaseHTTPResponse.geturl)r¥ N)NNF)NN)N)$r. r/ r0 rµ rM rR r ÚIOErrorr6 r: r~ Ú__annotations__Z ZstdErrorr9 r Úpropertyr! r r Úsetterr r r¬ r¯ r° r± r² r³ r¸ r¼ r» r¿ rÆ rÉ rÊ rË r( r( r( r) r| sb
|
|
|
÷ ÿ ü
|
ý
|
|
r| c sÔ e Zd ZdZdRddddd d
|
d
|
d d d ddd
|
d d d
|
dd fdd ZddddZddddZeddddZed dd d Z d
|
dd d Z
|
ddd d!Z d d"d#d$d%Z e d&dd'd(ZdSd"dd)d*d+ZdTd"dd)d,d-ZdUd"d/d
|
dd0d1d2ZdVd"d/d4d5d6d7Zd
|
dd8d9Zddd:d;Zed
|
dd<d=Zddd>d?Zddd@dAZd
|
ddBdCZdddDdEZd"dd)dFdGZdWd"d/d4d5dHdIZed ddJdKZ e j dLddMdNdKZ dOddPdQZ Z S )Xr aá
|
HTTP Response container.
|
|
Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is
|
loaded and decoded on-demand when the ``data`` property is accessed. This
|
class is also compatible with the Python standard library's :mod:`io`
|
module, and can hence be treated as a readable object in the context of that
|
framework.
|
|
Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`:
|
|
:param preload_content:
|
If True, the response's body will be preloaded during construction.
|
|
:param decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
|
:param original_response:
|
When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse`
|
object, it's convenient to include the original for debug purposes. It's
|
otherwise unused.
|
|
:param retries:
|
The retries contains the last :class:`~urllib3.util.retry.Retry` that
|
was used during the request.
|
|
:param enforce_content_length:
|
Enforce content length checking. Body returned by server must match
|
value of Content-Length header, if present. Otherwise, raise error.
|
r Nr Tr
|
r rk r r z_HttplibHTTPResponse | NonezHTTPConnectionPool | Noner z_HttplibHTTPMessage | Noner r2 )Úbodyr r
r r Úpreload_contentr Úoriginal_responseÚpoolr Úmsgr Úenforce_content_lengthÚrequest_methodr Ú
|
auto_closer" c s® t j||||||| d | | _|| _d | _d | _|| _d| _| | _|r\t |t
|
t fr\|| _| | _ |
|
| _ t|drx|| _d | _| |¡| _t | _|rª| jsª| j|d| _d S )N)r r
r r r r r r r¯ ©r )Úsuperr9 rÕ r× Ú_bodyÚ_fpÚ_original_responseÚ_fp_bytes_readrÔ r rU r Ú_poolÚ _connectionrN Ú
|
chunk_leftÚ _init_lengthÚlength_remainingrf Ú_decoded_bufferr¯ )r' rÐ r r
r r rÑ r rÒ rÓ r rÔ r rÕ rÖ r r× ©Ú __class__r( r) r9 s6 ù
|
|
|
zHTTPResponse.__init__r+ c C s( | j r | jsd S | j | j¡ d | _d S r# )rÞ rß Ú _put_connr, r( r( r) r± P s zHTTPResponse.release_connc C s. z | ¡ W n ttttfk
|
r( Y nX dS )zÏ
|
Read and discard any remaining HTTP response data in the response connection.
|
|
Unread data in the HTTPResponse connection blocks the connection from being released back to the pool.
|
N)r¯ r ÚOSErrorr r r, r( r( r) r² W s zHTTPResponse.drain_connr c C s" | j r | j S | jr | jddS d S )NT)r® )rÚ rÛ r¯ r, r( r( r) r! b s
|
zHTTPResponse.datac C s | j S r# )rß r, r( r( r) r m s zHTTPResponse.connectionc C s
|
t | jS r# )r rÛ r, r( r( r) Úisclosedq s zHTTPResponse.isclosedc C s | j S )zì
|
Obtain the number of bytes pulled over the wire so far. May differ from
|
the amount of content returned by :meth:``urllib3.response.HTTPResponse.read``
|
if bytes are encoded on the wire (e.g, compressed).
|
)rÝ r, r( r( r) Útellt s zHTTPResponse.tellr¦ )rÖ r" c C sâ | j d¡}|dk r| jr(t d¡ dS z8dd | d¡D }t|dkrVtd| | ¡ }W n t k
|
rx d}Y qX |d k rd}nd}zt
|
| j }W n t k
|
r² d }Y nX |d
|
ksÚd | krÐd k sÚn |d krÞd }|S )zM
|
Set initial length value for Response content if available.
|
zcontent-lengthNzÒReceived response with both Content-Length and Transfer-Encoding set. This is expressly forbidden by RFC 7230 sec 3.3.2. Ignoring Content-Length and attempting to process response as Transfer-Encoding: chunked.c S s h | ] }t |qS r( )rk )rY Úvalr( r( r) Ú <setcomp> s z,HTTPResponse._init_length.<locals>.<setcomp>r\ r z8Content-Length contained multiple unmatching values (%s)r )éÌ i0 éd éÈ ÚHEAD) r r{ r ÚlogÚwarningr] rn r Úpoprr rk r
)r' rÖ Úcontent_lengthÚlengthsÚlengthr
r( r( r) rá | s8 ÿ ÿÿ
|
|
&zHTTPResponse._init_lengthz$typing.Generator[(None, None, None)]c
|
c s d}zÂz
|
dV W n® tk
|
rB } zt| jdd|W 5 d}~X Y n~ tk
|
r } z*dt |krht
|
||t| jdd|W 5 d}~X Y n8 t t fk
|
r¾ } zt d|||W 5 d}~X Y nX d}W 5 |sì| j rÜ| j ¡ | jrì| j ¡ | j r| j ¡ r| ¡ X dS )zç
|
Catch low-level python exceptions, instead re-raising urllib3
|
variants, so that low-level exceptions are not leaked in the
|
high-level api.
|
|
On exit, release the connection back to the pool.
|
FNzRead timed out.zread operation timed outzConnection broken: T)rÜ r³ rß rè r± Ú SocketTimeoutr rÞ r rU r r rç r )r' Ú
|
clean_exitr¶ r( r( r) Ú_error_catcher´ s(
|
|
$
|
|
zHTTPResponse._error_catcher)rª r" c C sÆ | j s
|
td}|r||ks*| jr¤| j|kr¤tjs¤tjs@tjdk r¤t ¡ }d}|dks\|dkr|dk rxt
|
||}||8 }n|}| j |¡}|sq| |¡ ~qL| ¡ S |dk r¸| j |¡S | j ¡ S dS )a_
|
Read a response with the thought that reading the number of bytes
|
larger than can fit in a 32-bit int at a time via SSL in some
|
known cases leads to an overflow error that has to be prevented
|
if `amt` or `self.length_remaining` indicate that a problem may
|
happen.
|
|
The known cases:
|
* 3.8 <= CPython < 3.9.7 because of a bug
|
https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900.
|
* urllib3 injected with pyOpenSSL-backed SSL-support.
|
* CPython < 3.10 only when `amt` does not fit 32-bit int.
|
iÿÿÿ)é é
|
i Nr )rÛ ÚAssertionErrorrâ r ÚIS_SECURETRANSPORTÚ IS_PYOPENSSLÚsysÚ version_infors rt Úminr¯ rv rx )r' rª Z c_int_maxri Z max_chunk_amtZ chunk_amtr! r( r( r) Ú_fp_readì s<
|
þþýýûúú
|
|
|
zHTTPResponse._fp_readc C s¾ | j dkrdS t| j dd}| ¡ ^ |s4| |¡nd}|dk r~|dkr~|s~| j ¡ | jr~| jdk r~| jdkr~t| j| jW 5 Q R X |rº| jt |7 _| jdk rº| jt |8 _|S )z7
|
Reads `amt` of bytes from the socket.
|
NÚclosedFr3 r )
|
rÛ Úgetattrrø r r³ rÕ râ r rÝ rn )r' rª Ú fp_closedr! r( r( r) Ú _raw_read s&
|
|
|
ÿþý
|
|
zHTTPResponse._raw_readFr§ r c C s | ¡ |dkr| j}|dk r<d}t| j|kr<| j |¡S | |¡}d}|dkrXd}n|dkrh|shd}|s~t| jdkr~|S |dkr | |||¡}|r|| _nx|s¶| jr²t d|S | |||¡}| j
|
|¡ t| j|k r |r | |¡}| |||¡}| j
|
|¡ qÐ| j |¡}|S )aT
|
Similar to :meth:`http.client.HTTPResponse.read`, but with two additional
|
parameters: ``decode_content`` and ``cache_content``.
|
|
:param amt:
|
How much of the content to read. If specified, caching is skipped
|
because it doesn't make sense to cache partial content as the full
|
response.
|
|
:param decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
|
:param cache_content:
|
If True, will save the returned data such that the same result is
|
returned despite of the state of the underlying file object. This
|
is useful if you want the ``.data`` property to continue working
|
after having ``.read()`` the file object. (Overridden if ``amt`` is
|
set.)
|
NFTr rº ) r¸ r rn rã r{ r r¼ rÚ r rq ro )r' rª r r® r! r¹ Ú decoded_datar( r( r) r¯ F sB
|
ÿ
|
zHTTPResponse.readr¥ z#typing.Generator[bytes, None, None]r© c c sZ | j r$| ¡ r$| j||dE dH n2t| jr<t| jdkrV| j||d}|r$|V q$dS )a_
|
A generator wrapper for the read() method. A call will block until
|
``amt`` bytes have been read from the connection or until the
|
connection is closed.
|
|
:param amt:
|
How much of the content to read. The generator will return up to
|
much data per iteration, but may return less. This is particularly
|
likely when using compressed data. However, the empty string will
|
never be returned.
|
|
:param decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
rØ Nr )rª r )r Úsupports_chunked_readsr° r rÛ rn rã r¯ )r' rª r r! r( r( r) r¬ s zHTTPResponse.streamc C s dS )NTr( r, r( r( r) Úreadable s zHTTPResponse.readablec C s< | j s| jr| j ¡ | jr&| j ¡ | js8tj | ¡ d S r# )r rÛ r³ rß r× rs ÚIOBaser, r( r( r) r³ ° s
|
|
zHTTPResponse.closec C sT | j stjj | ¡S | jd kr"dS t| jdr8| j ¡ S t| jdrL| jjS dS d S )NTrè r )r× rs r r Ú__get__rÛ rN rè r, r( r( r) r º s
|
|
zHTTPResponse.closedc C s6 | j d krtdn t| j dr*| j ¡ S tdd S )Nz-HTTPResponse has no file to get a fileno fromÚfilenozOThe file-like object this HTTPResponse is wrapped around has no file descriptor)rÛ rç rN r r, r( r( r) r Ç s
|
|
|
ÿzHTTPResponse.filenoc C s2 | j d k r.t| j dr.t| j dds.| j ¡ S d S )Nr- r F)rÛ rN r r- r, r( r( r) r- Ò s ÿ
|
þ ýzHTTPResponse.flushc C s t | jdS )a
|
Checks if the underlying file-like object looks like a
|
:class:`http.client.HTTPResponse` object. We do this by testing for
|
the fp attribute. If it is present we assume it returns raw chunks as
|
processed by read_chunked().
|
Úfp)rN rÛ r, r( r( r) r Ú s z#HTTPResponse.supports_chunked_readsc C sh | j d k rd S | jj ¡ }| dd¡d }zt|d| _ W n( tk
|
rb | ¡ t| |d Y nX d S )Nó ;r r rF ) rà rÛ r Úreadliner] rk rr r³ r )r' Úliner( r( r) Ú_update_chunk_lengthã s
|
z!HTTPResponse._update_chunk_lengthc C s¶ d }|d kr2| j | j¡}|}| j d¡ d | _n| jd k rd|| jk rd| j |¡}| j| | _|}nN|| jkr| j |¡}| j d¡ d | _|}n | j | j¡}| j d¡ d | _|S )Nr@ )rÛ Ú
|
_safe_readrà )r' rª Úreturned_chunkrz Úvaluer( r( r) Ú _handle_chunkñ s&
|
zHTTPResponse._handle_chunkc c s | ¡ | jstd| ¡ s&td| ¡ Ð | jrXt| jrX| j ¡ W 5 Q R £ dS | j j
|
dkrrW 5 Q R £ dS | ¡ | j dkrq¬| |¡}| j||dd}|rr|V qr|rÂ| ¡ }|rÂ|V | j dk rê| j j
|
¡ }|sÞqê|dkrÂqêqÂ| jrú| j ¡ W 5 Q R X dS )aÆ
|
Similar to :meth:`HTTPResponse.read`, but with an additional
|
parameter: ``decode_content``.
|
|
:param amt:
|
How much of the content to read. If specified, caching is skipped
|
because it doesn't make sense to cache partial content as the full
|
response.
|
|
:param decode_content:
|
If True, will attempt to decode the body based on the
|
'content-encoding' header.
|
zHResponse is not chunked. Header 'transfer-encoding: chunked' is missing.zkBody should be http.client.HTTPResponse like. It should have have an fp attribute which returns raw chunks.Nr F)r r¹ s
|
)r¸ r r r r rø rÜ r r³ rÛ r r rà r r¼ r» r )r' rª r rz Údecodedr r( r( r) r° sL ÿÿ
|
|
|
|
ÿ
|
zHTTPResponse.read_chunkedc C s | j S )zÄ
|
Returns the URL that was the source of this response.
|
If the request that generated this response redirected, this method
|
will return the final redirect location.
|
©r r, r( r( r) r O s zHTTPResponse.urlrU r c C s
|
|| _ d S r# r r r( r( r) r X s r¨ c c s g }| j ddD ]n}d|krt| d¡}d |¡|d d V |dd
D ]}|d V qJ|d rn|d g}q~g }q| |¡ q|rd |¡V d S )NTrØ ó
|
r3 r r r¢ )r¬ r] Újoinrm )r' ri rz ÚchunksÚxr( r( r) Ú__iter__\ s
|
zHTTPResponse.__iter__)r Nr r NTTNNNNNTNNT)N)N)NNF)r¥ N)NN) r. r/ r0 rb r9 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 Ú __classcell__r( r( rä r) r ó sp " ï4<
|
872 þ, üL ÿ
|
ÿHr )QÚ
|
__future__r rg rs r r ÚloggingÚrerþ Útypingrà r6 Ú
|
contextlibr Ú http.clientr Z_HttplibHTTPMessager Z_HttplibHTTPResponseÚsocketr rö Z
|
brotlicffirM Ú ImportErrorZ zstandardrR ÚtupleÚmaprk ÚsearchÚ __version__ÚgroupsZ _zstd_versionÚAttributeErrorrr r r Z_base_connectionr
|
Ú _collectionsr r r r r Ú
|
exceptionsr r r r r r r r r r Z util.responser r Z
|
util.retryr Ú TYPE_CHECKINGZtyping_extensionsr Úconnectionpoolr Ú getLoggerr. rð r r1 r? rD rL rQ rT rW rf r r| r( r( r( r) Ú<module> sl
|
ÿ
|
|
0
|
|
|
; _
|
