o
    ¨Ýjª²  ã                   @  sâ  d dl mZ d dlZd dlZd dlZd dlZd dlZd dl	Z	d dl
Z
d dlZd dlmZmZ d dlmZmZ ddlmZmZmZmZ ddlmZmZmZmZmZmZmZ ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' dd	l(m)Z) dd
l*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z< g d¢Z=ddhZ>e
 ?d¡Z@d4dd„ZAd5d6dd„ZBd5d7dd „ZCd8d"d#„ZDd9d%d&„ZEd:d*d+„ZFG d,d-„ d-e
jGeHeHf ƒZIG d.d/„ d/ƒZJG d0d1„ d1ƒZKG d2d3„ d3e
jGeHeHf ƒZLdS );é    )ÚannotationsN)ÚAsyncGeneratorÚMapping)ÚCookieÚ	CookieJaré   )Ú
ByteStreamÚUnattachedStreamÚencode_requestÚencode_response)ÚByteChunkerÚContentDecoderÚIdentityDecoderÚLineDecoderÚMultiDecoderÚTextChunkerÚTextDecoder)ÚCookieConflictÚHTTPStatusErrorÚRequestNotReadÚResponseNotReadÚStreamClosedÚStreamConsumedÚrequest_context)Ú(get_multipart_boundary_from_content_type)Úcodes)ÚAsyncByteStreamÚCookieTypesÚHeaderTypesÚQueryParamTypesÚRequestContentÚRequestDataÚRequestExtensionsÚRequestFilesÚResponseContentÚResponseExtensionsÚSyncByteStream)ÚURL)Úto_bytes_or_strÚto_str)ÚCookiesÚHeadersÚRequestÚResponseÚauthorizationzproxy-authorizationÚ_TÚencodingÚstrÚreturnÚboolc                 C  s&   zt  | ¡ W dS  ty   Y dS w )z7
    Return `True` if `encoding` is a known codec.
    FT)ÚcodecsÚlookupÚLookupError©r0   © r8   úI/var/www/html/chatgpt/venv/lib/python3.10/site-packages/httpx2/_models.pyÚ_is_known_encoding:   s   þÿr:   Úkeyústr | bytesú
str | NoneÚbytesc                 C  s   t | tƒr| S |  |pd¡S )zE
    Coerce str/bytes into a strictly byte-wise HTTP header key.
    Úascii)Ú
isinstancer>   Úencode)r;   r0   r8   r8   r9   Ú_normalize_header_keyE   s   rB   Úvaluec                 C  s8   t | tƒr| S t | tƒstdt| ƒ› �ƒ‚|  |pd¡S )zG
    Coerce str/bytes into a strictly byte-wise HTTP header value.
    z'Header value must be str or bytes, not r?   )r@   r>   r1   Ú	TypeErrorÚtyperA   )rC   r0   r8   r8   r9   Ú_normalize_header_valueL   s
   

rF   Úcontent_typec                 C  s   t j ¡ }| |d< |jd d�S )Núcontent-type)Úfailobj)ÚemailÚmessageÚMessageÚget_content_charset)rG   Úmsgr8   r8   r9   Ú_parse_content_type_charsetW   s   
rO   úlist[dict[str, str]]c           	   
   C  sÆ   g }d}|   |¡} | s|S t d| ¡D ]M}z
| dd¡\}}W n ty-   |d}}Y nw d|  d¡i}| d¡D ] }z	| d¡\}} W n
 tyO   Y  nw |   |¡||  |¡< q:| |¡ q|S )	a7  
    Returns a list of parsed link headers, for more info see:
    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
    The generic syntax of those is:
    Link: < uri-reference >; param1=value1; param2="value2"
    So for instance:
    Link; '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;'
    would return
        [
            {"url": "http:/.../front.jpeg", "type": "image/jpeg"},
            {"url": "http://.../back.jpeg"},
        ]
    :param value: HTTP Link entity-header field
    :return: list of parsed link headers
    z '"z, *<ú;r   Ú Úurlz<> '"ú=)ÚstripÚreÚsplitÚ
ValueErrorÚappend)	rC   ÚlinksÚreplace_charsÚvalrS   ÚparamsÚlinkÚparamr;   r8   r8   r9   Ú_parse_header_links_   s*   
ÿÿr`   Úitemsú4typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]]ú4typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]c                 c  s:   � | D ]\}}t | ¡ ƒtv rtd|d�}||fV  qd S )Nz[secure])Zmatch_type_of)r)   ÚlowerÚSENSITIVE_HEADERSr(   )ra   ÚkÚvr8   r8   r9   Ú_obfuscate_sensitive_headers„   s   €ýrh   c                   @  s0  e Zd ZdZ		dOdPd	d
„ZedQdd„ƒZejdRdd„ƒZedSdd„ƒZdTdd„Z	dUdd„Z
dVdd„ZdWdd„ZejdXd d!„ƒZejdYd%d!„ƒZdZd[d(d!„Zd\d]d-d.„ZdZd^d/d0„Zd_d1d2„Zd`d5d6„Zd`d7d8„Zdad:d;„Zdbd<d=„Zdcd>d?„Zddd@dA„ZdedCdD„ZdfdFdG„ZdgdIdJ„ZdhdKdL„ZdQdMdN„ZdS )ir+   z9
    HTTP headers, as a case-insensitive multi-dict.
    NÚheadersúHeaderTypes | Noner0   r=   r2   ÚNonec                 C  s°   g | _ t|tƒrt|j ƒ| _ nDt|tƒr3| ¡ D ]\}}t||ƒ}t||ƒ}| j  || 	¡ |f¡ qn |d urS|D ]\}}t||ƒ}t||ƒ}| j  || 	¡ |f¡ q9|| _
d S ©N)Ú_listr@   r+   Úlistr   ra   rB   rF   rY   rd   Ú	_encoding)Úselfri   r0   rf   rg   Z	bytes_keyZbytes_valuer8   r8   r9   Ú__init__’   s   



ý


zHeaders.__init__r1   c              
   C  sj   | j du r2dD ]'}| jD ]\}}z| |¡ | |¡ W q ty&   Y  nw || _  | j S qd| _ | j S )zn
        Header encoding is mandated as ascii, but we allow fallbacks to utf-8
        or iso-8859-1.
        N)r?   úutf-8z
iso-8859-1)ro   ÚrawÚdecodeÚUnicodeDecodeError)rp   r0   r;   rC   r8   r8   r9   r0   ¨   s   

ÿö	zHeaders.encodingrC   c                 C  ó
   || _ d S rl   )ro   ©rp   rC   r8   r8   r9   r0   Á   ó   
úlist[tuple[bytes, bytes]]c                 C  ó   dd„ | j D ƒS )zH
        Returns a list of the raw header items, as byte pairs.
        c                 S  s   g | ]	\}}}||f‘qS r8   r8   )Ú.0Zraw_keyÚ_rC   r8   r8   r9   Ú
<listcomp>Ê   ó    zHeaders.raw.<locals>.<listcomp>©rm   ©rp   r8   r8   r9   rs   Å   s   zHeaders.rawútyping.KeysView[str]c                   s   ‡ fdd„ˆ j D ƒ ¡ S )Nc                   s    i | ]\}}}|  ˆ j¡d “qS rl   ©rt   r0   )r{   r|   r;   Ú_valuer€   r8   r9   Ú
<dictcomp>Í   s     z Headers.keys.<locals>.<dictcomp>)rm   Úkeysr€   r8   r€   r9   r…   Ì   s   zHeaders.keysútyping.ValuesView[str]c                 C  ó^   i }| j D ]%\}}}| | j¡}| | j¡}||v r&||  d|› �7  < q|||< q| ¡ S )Nú, )rm   rt   r0   Úvalues©rp   Zvalues_dictr|   r;   rC   Zstr_keyZ	str_valuer8   r8   r9   r‰   Ï   s   
zHeaders.valuesútyping.ItemsView[str, str]c                 C  r‡   )z›
        Return `(key, value)` items of headers. Concatenate headers
        into a single comma separated value when a key occurs multiple times.
        rˆ   )rm   rt   r0   ra   rŠ   r8   r8   r9   ra   Ú   s   
zHeaders.itemsúlist[tuple[str, str]]c                   s   ‡ fdd„ˆ j D ƒS )z¹
        Return a list of `(key, value)` pairs of headers. Allow multiple
        occurrences of the same key without concatenating into a single
        comma separated value.
        c                   s*   g | ]\}}}|  ˆ j¡|  ˆ j¡f‘qS r8   r‚   ©r{   r|   r;   rC   r€   r8   r9   r}   ï   ó   * z'Headers.multi_items.<locals>.<listcomp>r   r€   r8   r€   r9   Úmulti_itemsé   s   zHeaders.multi_itemsr;   c                C  ó   d S rl   r8   )rp   r;   r8   r8   r9   Úgetñ   ó   zHeaders.getÚdefaultr/   ústr | _Tc                 C  r�   rl   r8   ©rp   r;   r“   r8   r8   r9   r‘   ô   r’   ú	_T | Noneústr | _T | Nonec                 C  s"   z| | W S  t y   | Y S w )zˆ
        Return a header value. If multiple occurrences of the header occur
        then concatenate them together with commas.
        )ÚKeyErrorr•   r8   r8   r9   r‘   ÷   s
   
ÿFÚsplit_commasr3   ú	list[str]c                   sZ   |  ¡  ˆj¡‰ ‡ ‡fdd„ˆjD ƒ}|s|S g }|D ]}| dd„ | d¡D ƒ¡ q|S )zÆ
        Return a list of all header values for a given key.
        If `split_commas=True` is passed, then any comma separated header
        values are split into multiple return strings.
        c                   s*   g | ]\}}}|  ¡ ˆ kr| ˆj¡‘qS r8   )rd   rt   r0   )r{   r|   Úitem_keyZ
item_value©Zget_header_keyrp   r8   r9   r}   	  s
    
þz$Headers.get_list.<locals>.<listcomp>c                 S  s   g | ]}|  ¡ ‘qS r8   )rU   )r{   Úitemr8   r8   r9   r}     s    ú,)rd   rA   r0   rm   ÚextendrW   )rp   r;   r™   r‰   Zsplit_valuesrC   r8   rœ   r9   Úget_list  s   þzHeaders.get_listc                 C  s:   t |ƒ}| ¡ D ]}|| v r|  |¡ q| j |j¡ d S rl   )r+   r…   Úpoprm   rŸ   )rp   ri   r;   r8   r8   r9   Úupdate  s   
€zHeaders.updatec                 C  s   t | | jd�S )Nr7   )r+   r0   r€   r8   r8   r9   Úcopy  s   zHeaders.copyÚotherúMapping[str, str]c                 C  s$   t |tƒstS |  ¡ }| |¡ |S rl   )r@   r   ÚNotImplementedr£   r¢   ©rp   r¤   Zmergedr8   r8   r9   Ú__or__!  ó
   

zHeaders.__or__c                 C  s$   t |tƒstS t|ƒ}| | ¡ |S rl   )r@   r   r¦   r+   r¢   r§   r8   r8   r9   Ú__ror__(  r©   zHeaders.__ror__r   c                 C  s   |   |¡ | S rl   )r¢   )rp   r¤   r8   r8   r9   Ú__ior__/  s   
zHeaders.__ior__c                   s<   |  ¡  ˆj¡‰ ‡ ‡fdd„ˆjD ƒ}|rd |¡S t|ƒ‚)zÎ
        Return a single header value.

        If there are multiple headers with the same key, then we concatenate
        them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2
        c                   s&   g | ]\}}}|ˆ kr|  ˆj¡‘qS r8   r‚   )r{   r|   Ú
header_keyÚheader_value©Znormalized_keyrp   r8   r9   r}   <  s
    
þz'Headers.__getitem__.<locals>.<listcomp>rˆ   )rd   rA   r0   rm   Újoinr˜   )rp   r;   ra   r8   r®   r9   Ú__getitem__3  s   þ
zHeaders.__getitem__c                   s”   |  | jpd¡}|  | jpd¡}| ¡ ‰ ‡ fdd„t| jƒD ƒ}t|dd… ƒD ]}| j|= q(|r?|d }|ˆ |f| j|< dS | j |ˆ |f¡ dS )zs
        Set the header `key` to `value`, removing any duplicate entries.
        Retains insertion order.
        rr   c                   s"   g | ]\}\}}}|ˆ kr|‘qS r8   r8   ©r{   Úidxr|   r›   ©Z
lookup_keyr8   r9   r}   P  ó   " z'Headers.__setitem__.<locals>.<listcomp>r   Nr   )rA   ro   rd   Ú	enumeraterm   ÚreversedrY   )rp   r;   rC   Zset_keyÚ	set_valueZfound_indexesr²   r8   r³   r9   Ú__setitem__G  s   
zHeaders.__setitem__c                   sN   |  ¡  | j¡‰ ‡ fdd„t| jƒD ƒ}|st|ƒ‚t|ƒD ]}| j|= qdS )z*
        Remove the header `key`.
        c                   s&   g | ]\}\}}}|  ¡ ˆ kr|‘qS r8   )rd   r±   ©Zdel_keyr8   r9   r}   a  s   & z'Headers.__delitem__.<locals>.<listcomp>N)rd   rA   r0   rµ   rm   r˜   r¶   )rp   r;   Zpop_indexesr²   r8   r¹   r9   Ú__delitem__[  s   
ÿzHeaders.__delitem__ú
typing.Anyc                 C  s$   |  ¡  | j¡}|dd„ | jD ƒv S )Nc                 S  s   g | ]\}}}|‘qS r8   r8   )r{   r|   r;   r8   r8   r9   r}   k  s    z(Headers.__contains__.<locals>.<listcomp>)rd   rA   r0   rm   )rp   r;   r¬   r8   r8   r9   Ú__contains__i  s   zHeaders.__contains__útyping.Iterator[typing.Any]c                 C  s   t |  ¡ ƒS rl   )Úiterr…   r€   r8   r8   r9   Ú__iter__m  ó   zHeaders.__iter__Úintc                 C  ó
   t | jƒS rl   )Úlenrm   r€   r8   r8   r9   Ú__len__p  ó   
zHeaders.__len__c                 C  sR   zt |ƒ}W n
 ty   Y dS w dd„ | jD ƒ}dd„ |jD ƒ}t|ƒt|ƒkS )NFc                 S  ó   g | ]	\}}}||f‘qS r8   r8   r�   r8   r8   r9   r}   y  r~   z"Headers.__eq__.<locals>.<listcomp>c                 S  rÆ   r8   r8   r�   r8   r8   r9   r}   z  r~   )r+   rX   rm   Úsorted)rp   r¤   Zother_headersZ	self_listZ
other_listr8   r8   r9   Ú__eq__s  s   ÿzHeaders.__eq__c                 C  sv   | j j}d}| jdkrd| j›�}tt|  ¡ ƒƒ}t|ƒ}t|ƒt|ƒk}|r1|› d|›|› d�S |› d|›|› d�S )NrR   r?   z, encoding=ú(ú))Ú	__class__Ú__name__r0   rn   rh   r�   ÚdictrÃ   )rp   Ú
class_nameZencoding_strZas_listÚas_dictZno_duplicate_keysr8   r8   r9   Ú__repr__}  s   
zHeaders.__repr__©NN)ri   rj   r0   r=   r2   rk   ©r2   r1   ©rC   r1   r2   rk   )r2   ry   )r2   r�   )r2   r†   )r2   r‹   )r2   rŒ   )r;   r1   r2   r=   )r;   r1   r“   r/   r2   r”   rl   )r;   r1   r“   r–   r2   r—   )F)r;   r1   r™   r3   r2   rš   )ri   rj   r2   rk   )r2   r+   )r¤   r¥   r2   r+   )r¤   r   r2   r+   )r;   r1   r2   r1   )r;   r1   rC   r1   r2   rk   )r;   r1   r2   rk   )r;   r»   r2   r3   )r2   r½   ©r2   rÁ   )r¤   r»   r2   r3   )rÌ   Ú
__module__Ú__qualname__Ú__doc__rq   Úpropertyr0   Úsetterrs   r…   r‰   ra   r�   ÚtypingÚoverloadr‘   r    r¢   r£   r¨   rª   r«   r°   r¸   rº   r¼   r¿   rÄ   rÈ   rÐ   r8   r8   r8   r9   r+   �   sD    ý
















r+   c                
   @  sv   e Zd Zddddddddddœ	d0dd„Zd1dd „Zed2d"d#„ƒZd2d$d%„Zd2d&d'„Zd3d(d)„Z	d4d+d,„Z
d5d.d/„ZdS )6r,   N)	r]   ri   ÚcookiesÚcontentÚdataÚfilesÚjsonÚstreamÚ
extensionsÚmethodr1   rS   ú	URL | strr]   úQueryParamTypes | Noneri   rj   rÜ   úCookieTypes | NonerÝ   úRequestContent | NonerÞ   úRequestData | Nonerß   úRequestFiles | Nonerà   útyping.Any | Nonerá   ú'SyncByteStream | AsyncByteStream | Nonerâ   úRequestExtensions | Noner2   rk   c       	      	   C  sÐ   |  ¡ | _|d u rt|ƒnt||d�| _t|ƒ| _|d u ri nt|ƒ| _|r-t|ƒ 	| ¡ |
d u rc| j 
d¡}t||||	t|rF| | jj¡nd d�d�\}}
|  |¡ |
| _t|
tƒra|  ¡  d S d S |
| _d S )N)r]   rH   )rG   )rÝ   rÞ   rß   rà   Úboundary)Úupperrã   r'   rS   r+   ri   rÍ   râ   r*   Úset_cookie_headerr‘   r
   r   rA   r0   Ú_preparerá   r@   r   Úread)rp   rã   rS   r]   ri   rÜ   rÝ   rÞ   rß   rà   rá   râ   rG   r8   r8   r9   rq   Ž  s.   

ÿ
û
	
ÿ
zRequest.__init__Údefault_headersúdict[str, str]c                 C  s¾   |  ¡ D ]#\}}| ¡ dkrd| jv rq| ¡ dkr d| jv r q| j ||¡ qg }d| jv }d| jv p8d| jv }|sH| jjrH| d| jjf¡ |sT| jdv rT| d¡ t	|| jj
 ƒ| _d S )	Núcontent-lengthzTransfer-Encodingútransfer-encodingzContent-LengthÚHosts   Host)ÚPOSTÚPUTÚPATCHZQUERY)s   Content-Lengthó   0)ra   rd   ri   Ú
setdefaultrS   ÚhostrY   Únetlocrã   r+   rs   )rp   rò   r;   rC   Zauto_headersZhas_hostZhas_content_lengthr8   r8   r9   rð   Æ  s   

zRequest._preparer>   c                 C  ó   t | dƒstƒ ‚| jS ©NÚ_content)Úhasattrr   r   r€   r8   r8   r9   rÝ   Ü  ó   
zRequest.contentc                 C  sH   t | dƒs!t| jtjƒsJ ‚d | j¡| _t| jtƒs!t| jƒ| _| jS )ú6
        Read and return the request content.
        r   ó    )r  r@   rá   rÚ   ÚIterabler¯   r   r   r€   r8   r8   r9   rñ   â  s   
zRequest.readc                 Ã  sZ   �t | dƒs*t| jtjƒsJ ‚d dd„ | j2 ƒI dH ¡| _t| jtƒs*t| jƒ| _| jS )r  r   r  c                 Ó  ó   �g | z3 d H W }|‘q6 S rl   r8   ©r{   Úpartr8   r8   r9   r}   ö  ó   € z!Request.aread.<locals>.<listcomp>N)r  r@   rá   rÚ   ÚAsyncIterabler¯   r   r   r€   r8   r8   r9   Úareadð  s   €
zRequest.areadc                 C  s,   | j j}t| jƒ}d|› d| j›d|›d�S )Nú<rÉ   rˆ   z)>)rË   rÌ   r1   rS   rã   )rp   rÎ   rS   r8   r8   r9   rÐ   þ  s   
zRequest.__repr__údict[str, typing.Any]c                 C  ó   dd„ | j  ¡ D ƒS )Nc                 S  ó   i | ]\}}|d vr||“qS ))râ   rá   r8   ©r{   ÚnamerC   r8   r8   r9   r„     s    z(Request.__getstate__.<locals>.<dictcomp>©Ú__dict__ra   r€   r8   r8   r9   Ú__getstate__  ó   zRequest.__getstate__Ústatec                 C  s0   |  ¡ D ]
\}}t| ||ƒ qi | _tƒ | _d S rl   )ra   Úsetattrrâ   r	   rá   ©rp   r  r  rC   r8   r8   r9   Ú__setstate__  s   zRequest.__setstate__)rã   r1   rS   rä   r]   rå   ri   rj   rÜ   ræ   rÝ   rç   rÞ   rè   rß   ré   rà   rê   rá   rë   râ   rì   r2   rk   ©rò   ró   r2   rk   ©r2   r>   rÒ   ©r2   r  ©r  r  r2   rk   )rÌ   rÕ   rÖ   rq   rð   rØ   rÝ   rñ   r  rÐ   r  r  r8   r8   r8   r9   r,   �  s&    ó
8



r,   c                   @  s2  e Zd Zdddddddddddœ
d‚dd„Zdƒdd „Zed„d"d#„ƒZejd…d%d#„ƒZed†d'd(„ƒZejd‡d*d(„ƒZedˆd,d-„ƒZ	edˆd.d/„ƒZ
ed‰d1d2„ƒZedŠd4d5„ƒZedˆd6d7„ƒZed‹d8d9„ƒZejdŒd:d9„ƒZed‹d;d<„ƒZd�d>d?„ZedŽdAdB„ƒZedŽdCdD„ƒZedŽdEdF„ƒZedŽdGdH„ƒZedŽdIdJ„ƒZedŽdKdL„ƒZedŽdMdN„ƒZd�dOdP„Zd�dRdS„Zed‘dUdV„ƒZed’dXdY„ƒZed“dZd[„ƒZdˆd\d]„Zd”d_d`„Zd•dbdc„ZdŠddde„Z d–d—didj„Z!d–d˜dldm„Z"d™dndo„Z#d–d—dpdq„Z$dšdrds„Z%dŠdtdu„Z&d–d›dwdx„Z'd–dœdzd{„Z(d�d|d}„Z)d–d›d~d„Z*dšd€d�„Z+dS )žr-   Nrr   )
ri   rÝ   ÚtextÚhtmlrà   rá   Úrequestrâ   ÚhistoryÚdefault_encodingÚstatus_coderÁ   ri   rj   rÝ   úResponseContent | Noner  r=   r  rà   r»   rá   rë   r   úRequest | Nonerâ   úResponseExtensions | Noner!  úlist[Response] | Noner"  ú*str | typing.Callable[[bytes], str | None]r2   rk   c       
         C  s¨   || _ t|ƒ| _|| _d | _|	d u ri nt|	ƒ| _|
d u rg nt|
ƒ| _d| _	d| _
|| _|d u rLt||||ƒ\}}|  |¡ || _t|tƒrK|  ¡  n|| _d| _d S )NFr   )r#  r+   ri   Ú_requestZnext_requestrÍ   râ   rn   r!  Ú	is_closedÚis_stream_consumedr"  r   rð   rá   r@   r   rñ   Ú_num_bytes_downloaded)rp   r#  ri   rÝ   r  r  rà   rá   r   râ   r!  r"  r8   r8   r9   rq     s$   


€
zResponse.__init__rò   ró   c                 C  s<   |  ¡ D ]\}}| ¡ dkrd| jv rq| j ||¡ qd S )Nrõ   rô   )ra   rd   ri   rû   )rp   rò   r;   rC   r8   r8   r9   rð   E  s
   üzResponse._prepareúdatetime.timedeltac                 C  s2   t | dƒst| jddƒ}|dur|S tdƒ‚| jS )ze
        Returns the time taken for the complete request/response
        cycle to complete.
        Ú_elapsedÚelapsedNzK'.elapsed' may only be accessed after the response has been read or closed.)r  Úgetattrrá   ÚRuntimeErrorr.  )rp   Zstream_elapsedr8   r8   r9   r/  L  s   
zResponse.elapsedr/  c                 C  rv   rl   )r.  )rp   r/  r8   r8   r9   r/  Y  rx   r,   c                 C  s   | j du r	tdƒ‚| j S )zR
        Returns the request instance associated to the current response.
        Nz7The request instance has not been set on this response.)r)  r1  r€   r8   r8   r9   r   ]  s   
zResponse.requestrC   c                 C  rv   rl   )r)  rw   r8   r8   r9   r   f  rx   r1   c                 C  s2   z| j d }W n
 ty   Y dS w |jddd�S )NÚhttp_versionzHTTP/1.1r?   Úignore©Úerrors)râ   r˜   rt   )rp   r2  r8   r8   r9   r2  j  s   ÿzResponse.http_versionc                 C  s<   z| j d }W n ty   t | j¡ Y S w |jddd�S )NÚreason_phraser?   r3  r4  )râ   r˜   r   Zget_reason_phraser#  rt   )rp   r6  r8   r8   r9   r6  s  s   ÿzResponse.reason_phraser'   c                 C  s   | j jS )zA
        Returns the URL for which the request was made.
        )r   rS   r€   r8   r8   r9   rS   |  s   zResponse.urlr>   c                 C  rþ   rÿ   )r  r   r   r€   r8   r8   r9   rÝ   ƒ  r  zResponse.contentc                 C  sR   t | dƒs&| j}|sd| _| jS t| jpdd�}d | | j¡| ¡ g¡| _| jS )NÚ_textrR   rr   r7   )r  rÝ   r7  r   r0   r¯   rt   Úflush)rp   rÝ   Údecoderr8   r8   r9   r  ‰  s   
þzResponse.textc                 C  sZ   t | dƒs*| j}|du st|ƒs%t| jtƒr| j}nt | dƒr%|  | j¡}|p(d| _| jS )aï  
        Return an encoding to use for decoding the byte content into text.
        The priority for determining this is given by...

        * `.encoding = <>` has been set explicitly.
        * The encoding as specified by the charset parameter in the Content-Type header.
        * The encoding as determined by `default_encoding`, which may either be
          a string like "utf-8" indicating the encoding to use, or may be a callable
          which enables charset autodetection.
        ro   Nr   rr   )r  Úcharset_encodingr:   r@   r"  r1   r   ro   )rp   r0   r8   r8   r9   r0   ”  s   


zResponse.encodingc                 C  s   t | dƒr	tdƒ‚|| _dS )zÆ
        Set the encoding to use for decoding the byte content into text.

        If the `text` attribute has been accessed, attempting to set the
        encoding will throw a ValueError.
        r7  z?Setting encoding after `text` has been accessed is not allowed.N)r  rX   ro   rw   r8   r8   r9   r0   ª  s   

c                 C  s    | j  d¡}|du rdS t|ƒS )zO
        Return the encoding, as specified by the Content-Type header.
        zContent-TypeN)ri   r‘   rO   )rp   rG   r8   r8   r9   r:  ¶  s   zResponse.charset_encodingr   c                 C  sz   t | dƒs:| jjddd�}dd„ |D ƒ}tdd„ |D ƒƒ}t|jƒdkr-|jd	 | _| jS |jr6|| _| jS tƒ | _| jS )
zž
        Returns a decoder instance which can be used to decode the raw byte
        content, depending on the Content-Encoding used in the response.
        Ú_decoderzcontent-encodingT)r™   c                 S  s   g | ]}|  ¡  ¡ ‘qS r8   )rU   rd   )r{   rC   r8   r8   r9   r}   È  ó    z1Response._get_content_decoder.<locals>.<listcomp>c                 S  s   g | ]}|d kr|‘qS )Úidentityr8   )r{   r0   r8   r8   r9   r}   É  r<  r   r   )r  ri   r    r   rÃ   Úchildrenr;  r   )rp   r‰   Ú	encodingsr9  r8   r8   r9   Ú_get_content_decoderÁ  s   
ûþzResponse._get_content_decoderr3   c                 C  ó   t  | j¡S )zU
        A property which is `True` for 1xx status codes, `False` otherwise.
        )r   Úis_informationalr#  r€   r8   r8   r9   rB  Ó  ó   zResponse.is_informationalc                 C  rA  )zU
        A property which is `True` for 2xx status codes, `False` otherwise.
        )r   Ú
is_successr#  r€   r8   r8   r9   rD  Ú  rC  zResponse.is_successc                 C  rA  )a  
        A property which is `True` for 3xx status codes, `False` otherwise.

        Note that not all responses with a 3xx status code indicate a URL redirect.

        Use `response.has_redirect_location` to determine responses with a properly
        formed URL redirection.
        )r   Úis_redirectr#  r€   r8   r8   r9   rE  á  s   
zResponse.is_redirectc                 C  rA  )zU
        A property which is `True` for 4xx status codes, `False` otherwise.
        )r   Úis_client_errorr#  r€   r8   r8   r9   rF  í  rC  zResponse.is_client_errorc                 C  rA  )zU
        A property which is `True` for 5xx status codes, `False` otherwise.
        )r   Úis_server_errorr#  r€   r8   r8   r9   rG  ô  rC  zResponse.is_server_errorc                 C  rA  )z]
        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
        )r   Úis_errorr#  r€   r8   r8   r9   rH  û  rC  zResponse.is_errorc                 C  s(   | j tjtjtjtjtjfv od| jv S )zs
        Returns True for 3xx responses with a properly formed URL redirection,
        `False` otherwise.
        ZLocation)r#  r   ÚMOVED_PERMANENTLYÚFOUNDÚ	SEE_OTHERÚTEMPORARY_REDIRECTÚPERMANENT_REDIRECTri   r€   r8   r8   r9   Úhas_redirect_location  s   öÿòzResponse.has_redirect_locationc                 C  sp   | j }|du rtdƒ‚| jr| S | jrd}nd}| jd }dddd	d
œ}| |d¡}|j| |d�}t||| d�‚)z>
        Raise the `HTTPStatusError` if one occurred.
        NzYCannot call `raise_for_status` as the request instance has not been set on this response.zÒ{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'
Redirect location: '{0.headers[location]}'
For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}z§{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'
For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}éd   zInformational responsezRedirect responsezClient errorzServer error)r   é   é   é   zInvalid status code)Ú
error_type)r   Úresponse)r)  r1  rD  rN  r#  r‘   Úformatr   )rp   r   rK   Zstatus_classZerror_typesrS  r8   r8   r9   Úraise_for_status  s*   ÿÿÿ
üzResponse.raise_for_statusÚkwargsc                 K  s   t j| jfi |¤ŽS rl   )ÚjsonlibÚloadsrÝ   )rp   rW  r8   r8   r9   rà   =  r  zResponse.jsonr*   c                 C  s$   t | dƒstƒ | _| j | ¡ | jS )NÚ_cookies)r  r*   rZ  Úextract_cookiesr€   r8   r8   r9   rÜ   @  s   
zResponse.cookiesú dict[str | None, dict[str, str]]c                 C  s*   | j  d¡}|du ri S dd„ t|ƒD ƒS )zI
        Returns the parsed header links of the response, if any
        r^   Nc                 S  s"   i | ]}|  d ¡p|  d¡|“qS )ÚrelrS   )r‘   )r{   r^   r8   r8   r9   r„   P  r´   z"Response.links.<locals>.<dictcomp>)ri   r‘   r`   )rp   Úheaderr8   r8   r9   rZ   G  s   zResponse.linksc                 C  s   | j S rl   )r,  r€   r8   r8   r9   Únum_bytes_downloadedR  s   zResponse.num_bytes_downloadedc                 C  s   d| j › d| j› d�S )Nz<Response [ú ú]>)r#  r6  r€   r8   r8   r9   rÐ   V  s   zResponse.__repr__r  c                 C  r  )Nc                 S  r  ))râ   rá   r*  r;  r8   r  r8   r8   r9   r„   Z  s
    þz)Response.__getstate__.<locals>.<dictcomp>r  r€   r8   r8   r9   r  Y  s   þzResponse.__getstate__r  c                 C  s6   |  ¡ D ]
\}}t| ||ƒ qd| _i | _tƒ | _d S )NT)ra   r  r*  râ   r	   rá   r  r8   r8   r9   r  `  s
   zResponse.__setstate__c                 C  s    t | dƒsd |  ¡ ¡| _| jS )ú7
        Read and return the response content.
        r   r  )r  r¯   Ú
iter_bytesr   r€   r8   r8   r9   rñ   g  s   
zResponse.readÚ
chunk_sizeú
int | Noneútyping.Iterator[bytes]c                 c  s  � t | dƒr,|du rt| jƒn|}tdt| jƒt|dƒƒD ]}| j||| … V  qdS |  ¡ }t|d�}t| jd��? |  	¡ D ]}| 
|¡D ]}| 
|¡D ]}|V  qNqGq@| ¡ D ]}| 
|¡D ]}|V  qaqZ| ¡ D ]}|V  qlW d  ƒ dS 1 s}w   Y  dS ©z˜
        A byte-iterator over the decoded response content.
        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
        r   Nr   r   ©rd  ©r   )r  rÃ   r   ÚrangeÚmaxr@  r   r   r)  Úiter_rawrt   r8  )rp   rd  Úir9  ÚchunkerÚ	raw_bytesÚdecodedÚchunkr8   r8   r9   rc  o  s.   €
ÿ
ÿÿÿÿ"øzResponse.iter_bytesútyping.Iterator[str]c                 c  s®   � t | jpdd�}t|d�}t| jd��9 |  ¡ D ]}| |¡}| |¡D ]}|V  q%q| ¡ }| |¡D ]}|V  q5| ¡ D ]}|V  q?W d  ƒ dS 1 sPw   Y  dS ©z§
        A str-iterator over the decoded response content
        that handles both gzip, deflate, etc but also detects the content's
        string encoding.
        rr   r7   rh  ri  N)r   r0   r   r   r)  rc  rt   r8  ©rp   rd  r9  rn  Zbyte_contentZtext_contentrq  r8   r8   r9   Ú	iter_text†  s    €

ÿÿ"øzResponse.iter_textc                 c  sr   � t ƒ }t| jd��% |  ¡ D ]}| |¡D ]}|V  qq| ¡ D ]}|V  q!W d   ƒ d S 1 s2w   Y  d S ©Nri  )r   r   r)  ru  rt   r8  ©rp   r9  r  Úliner8   r8   r9   Ú
iter_lines™  s   €ÿÿ"üzResponse.iter_linesc                 c  sÒ   � | j rtƒ ‚| jrtƒ ‚t| jtƒstdƒ‚d| _ d| _t	|d�}zAt
| jd��" | jD ]}|  jt|ƒ7  _| |¡D ]}|V  q=q-W d  ƒ n1 sNw   Y  | ¡ D ]}|V  qWW |  ¡  dS |  ¡  w )ú@
        A byte-iterator over the raw response content.
        z5Attempted to call a sync iterator on an async stream.Tr   rh  ri  N)r+  r   r*  r   r@   rá   r&   r1  r,  r   r   r)  rÃ   rt   r8  Úclose)rp   rd  rn  Úraw_stream_bytesrq  r8   r8   r9   rl  ¢  s.   €

ÿþÿÿzResponse.iter_rawc                 C  s`   t | jtƒs
tdƒ‚| js.d| _t| jd�� | j ¡  W d  ƒ dS 1 s'w   Y  dS dS )ú‰
        Close the response and release the connection.
        Automatically called if the response body is read to completion.
        z2Attempted to call a sync close on an async stream.Tri  N)r@   rá   r&   r1  r*  r   r)  r{  r€   r8   r8   r9   r{  ½  s   "ÿþzResponse.closec              	   Ã  st   �t | dƒs7t |  ¡ ¡4 I dH š}d dd„ |2 ƒI dH ¡| _W d  ƒI dH  | jS 1 I dH s2w   Y  | jS )rb  r   Nr  c                 Ó  r  rl   r8   r  r8   r8   r9   r}   Ð  r	  z"Response.aread.<locals>.<listcomp>)r  Ú
contextlibÚaclosingÚaiter_bytesr¯   r   )rp   Úpartsr8   r8   r9   r  Ê  s   €
ÿþzResponse.areadú"typing.AsyncGenerator[bytes, None]c           	   
   C sP  �t | dƒr,|du rt| jƒn|}tdt| jƒt|dƒƒD ]}| j||| … V  qdS |  ¡ }t|d�}t| jd��c t	 
|  ¡ ¡4 I dH š(}|2 z3 dH W }| |¡D ]}| |¡D ]}|V  q\qUqJ6 W d  ƒI dH  n1 I dH suw   Y  | ¡ D ]}| |¡D ]}|V  q…q~| ¡ D ]}|V  q�W d  ƒ dS 1 s¡w   Y  dS rg  )r  rÃ   r   rj  rk  r@  r   r   r)  r~  r  Ú	aiter_rawrt   r8  )	rp   rd  rm  r9  rn  Z
raw_streamro  rp  rq  r8   r8   r9   r€  Ó  s4   €
ÿ
ÿÿÿ(ÿÿÿ"÷zResponse.aiter_bytesútyping.AsyncIterator[str]c                 C s¸   �t | jpdd�}t|d�}t| jd��> |  ¡ 2 z3 dH W }| |¡}| |¡D ]}|V  q)q6 | ¡ }| |¡D ]}|V  q:| ¡ D ]}|V  qDW d  ƒ dS 1 sUw   Y  dS rs  )r   r0   r   r   r)  r€  rt   r8  rt  r8   r8   r9   Ú
aiter_textë  s"   €

ÿþÿ"øzResponse.aiter_textc                 C s|   �t ƒ }t| jd��* |  ¡ 2 z3 d H W }| |¡D ]}|V  qq6 | ¡ D ]}|V  q&W d   ƒ d S 1 s7w   Y  d S rv  )r   r   r)  r…  rt   r8  rw  r8   r8   r9   Úaiter_linesþ  s   €ÿÿÿ"üzResponse.aiter_linesc              	   C s   �| j rtƒ ‚| jrtƒ ‚t| jtƒstdƒ‚d| _ d| _t	|d�}| j 
¡ }zTt| jd��& |2 z3 dH W }|  jt|ƒ7  _| |¡D ]}|V  qEq16 W d  ƒ n1 sWw   Y  | ¡ D ]}|V  q`W t|tƒrs| ¡ I dH  |  ¡ I dH  dS t|tƒrˆ| ¡ I dH  |  ¡ I dH  w )rz  z5Attempted to call an async iterator on a sync stream.Tr   rh  ri  N)r+  r   r*  r   r@   rá   r   r1  r,  r   Ú	__aiter__r   r)  rÃ   rt   r8  r   Úaclose)rp   rd  rn  rá   r|  rq  r8   r8   r9   rƒ    s:   €

ÿþÿÿ

þzResponse.aiter_rawc                 Ã  sh   �t | jtƒstdƒ‚| js2d| _t| jd�� | j ¡ I dH  W d  ƒ dS 1 s+w   Y  dS dS )r}  z2Attempted to call an async close on a sync stream.Tri  N)r@   rá   r   r1  r*  r   r)  rˆ  r€   r8   r8   r9   rˆ  %  s   €"ÿþzResponse.aclose)r#  rÁ   ri   rj   rÝ   r$  r  r=   r  r=   rà   r»   rá   rë   r   r%  râ   r&  r!  r'  r"  r(  r2   rk   r  )r2   r-  )r/  r-  r2   rk   )r2   r,   )rC   r,   r2   rk   rÒ   )r2   r'   r  )r2   r=   rÓ   )r2   r   ©r2   r3   )r2   r-   )rW  r»   r2   r»   )r2   r*   )r2   r\  rÔ   r  r  rl   )rd  re  r2   rf  )rd  re  r2   rr  ©r2   rr  )r2   rk   )rd  re  r2   r‚  )rd  re  r2   r„  )r2   r„  ),rÌ   rÕ   rÖ   rq   rð   rØ   r/  rÙ   r   r2  r6  rS   rÝ   r  r0   r:  r@  rB  rD  rE  rF  rG  rH  rN  rV  rà   rÜ   rZ   r_  rÐ   r  r  rñ   rc  ru  ry  rl  r{  r  r€  r…  r†  rƒ  rˆ  r8   r8   r8   r9   r-     s–    ó
7




$





	

	
	r-   c                   @  sÞ   e Zd ZdZd9d:dd„Zd;dd„Zd<dd„Zd=d>dd„Z			d?d@dd„Z		dAdBdd„Z	dAdCd d!„Z
d9d:d"d#„ZdDd$d%„ZdEd&d'„ZdFd(d)„ZdGd+d,„ZdHd.d/„ZdId1d2„ZdJd3d4„ZG d5d6„ d6ejjƒZG d7d8„ d8ƒZdS )Kr*   z-
    HTTP Cookies, as a mutable mapping.
    NrÜ   ræ   r2   rk   c                 C  s²   |d u s	t |tƒr%tƒ | _t |tƒr!| ¡ D ]\}}|  ||¡ qd S d S t |tƒr=tƒ | _|D ]
\}}|  ||¡ q0d S t |tƒrTtƒ | _|jD ]}| j |¡ qId S || _d S rl   )	r@   rÍ   r   Újarra   Úsetrn   r*   Ú
set_cookie)rp   rÜ   r;   rC   Úcookier8   r8   r9   rq   8  s$   
þ
ÿ

ÿ
zCookies.__init__rT  r-   c                 C  s@   d|j vrd|j vrdS |  |¡}|  |j¡}| j ||¡ dS )zO
        Loads any cookies based on the response `Set-Cookie` headers.
        z
set-cookiezset-cookie2N)ri   Ú_CookieCompatResponseÚ_CookieCompatRequestr   r‹  r[  )rp   rT  Zurllib_responseÚurllib_requestr8   r8   r9   r[  I  s
   
zCookies.extract_cookiesr   r,   c                 C  s   |   |¡}| j |¡ dS )zM
        Sets an appropriate 'Cookie:' HTTP header on the `Request`.
        N)r�  r‹  Úadd_cookie_header)rp   r   r‘  r8   r8   r9   rï   U  s   
zCookies.set_cookie_headerrR   ú/r  r1   rC   ÚdomainÚpathc                 C  sš   i dd“d|“d|“dd“dd“d	|“d
t |ƒ“d| d¡“d|“dt |ƒ“dd“dd“dd“dd“dd“dddi“dd“}tdi |¤Ž}| j |¡ dS )zU
        Set a cookie value by name. May optionally include domain and path.
        Úversionr   r  rC   ÚportNÚport_specifiedFr”  Údomain_specifiedÚdomain_initial_dotÚ.r•  Úpath_specifiedÚsecureÚexpiresÚdiscardTÚcommentÚcomment_urlÚrestÚHttpOnlyÚrfc2109r8   )r3   Ú
startswithr   r‹  r�  )rp   r  rC   r”  r•  rW  rŽ  r8   r8   r9   rŒ  \  sJ   ÿþýüûúù
ø	÷
öõôóòñðïzCookies.setr“   r=   c                 C  sn   d}| j D ])}|j|kr.|du s|j|kr.|du s|j|kr.|dur+d|› �}t|ƒ‚|j}q|du r5|S |S )zŒ
        Get a cookie by name. May optionally include domain and path
        in order to specify exactly which cookie to retrieve.
        Nz!Multiple cookies exist with name=)r‹  r  r”  r•  r   rC   )rp   r  r“   r”  r•  rC   rŽ  rK   r8   r8   r9   r‘   v  s   


€zCookies.getc                   s\   ˆ durˆdur| j  ˆ ˆˆ¡S ‡ ‡‡fdd„| j D ƒ}|D ]}| j  |j|j|j¡ qdS )z�
        Delete a cookie by name. May optionally include domain and path
        in order to specify exactly which cookie to delete.
        Nc                   s>   g | ]}|j ˆkrˆ d u s|jˆ krˆd u s|jˆkr|‘qS rl   )r  r”  r•  ©r{   rŽ  ©r”  r  r•  r8   r9   r}   œ  s    
üz"Cookies.delete.<locals>.<listcomp>)r‹  Úclearr”  r•  r  )rp   r  r”  r•  ÚremoverŽ  r8   r§  r9   Údelete�  s   
þÿzCookies.deletec                 C  sD   g }|dur|  |¡ |dur|dusJ ‚|  |¡ | jj|Ž  dS )z‡
        Delete all cookies. Optionally include a domain and path in
        order to only delete a subset of all the cookies.
        N)rY   r‹  r¨  )rp   r”  r•  Úargsr8   r8   r9   r¨  §  s   

zCookies.clearc                 C  s$   t |ƒ}|jD ]}| j |¡ qd S rl   )r*   r‹  r�  )rp   rÜ   rŽ  r8   r8   r9   r¢   ´  s   
ÿzCookies.updatec                 C  s   |   ||¡S rl   )rŒ  ©rp   r  rC   r8   r8   r9   r¸   ¹  rÀ   zCookies.__setitem__c                 C  s   |   |¡}|d u rt|ƒ‚|S rl   )r‘   r˜   r¬  r8   r8   r9   r°   ¼  s   
zCookies.__getitem__c                 C  s
   |   |¡S rl   )rª  )rp   r  r8   r8   r9   rº   Â  rÅ   zCookies.__delitem__rÁ   c                 C  rÂ   rl   )rÃ   r‹  r€   r8   r8   r9   rÄ   Å  rÅ   zCookies.__len__rr  c                 C  rz   )Nc                 s  s   � | ]}|j V  qd S rl   )r  r¦  r8   r8   r9   Ú	<genexpr>É  s   € z#Cookies.__iter__.<locals>.<genexpr>©r‹  r€   r8   r8   r9   r¿   È  s   zCookies.__iter__r3   c                 C  s   | j D ]} dS dS )NTFr®  )rp   r|   r8   r8   r9   Ú__bool__Ë  s   
zCookies.__bool__c                 C  s"   d  dd„ | jD ƒ¡}d|› d�S )Nrˆ   c              	   S  s*   g | ]}d |j › d|j› d|j› d�‘qS )z<Cookie rT   z for z />)r  rC   r”  r¦  r8   r8   r9   r}   Ò  rŽ   z$Cookies.__repr__.<locals>.<listcomp>z	<Cookies[ra  )r¯   r‹  )rp   Zcookies_reprr8   r8   r9   rÐ   Ð  s   ÿzCookies.__repr__c                      s0   e Zd ZdZd‡ fdd„Zd‡ fdd„Z‡  ZS )zCookies._CookieCompatRequestú‚
        Wraps a `Request` instance up in a compatibility interface suitable
        for use with `CookieJar` operations.
        r   r,   r2   rk   c                   s*   t ƒ jt|jƒt|jƒ|jd� || _d S )N)rS   ri   rã   )Úsuperrq   r1   rS   rÍ   ri   rã   r   )rp   r   ©rË   r8   r9   rq   Ý  s   ý
z%Cookies._CookieCompatRequest.__init__r;   r1   r\   c                   s   t ƒ  ||¡ || jj|< d S rl   )r±  Úadd_unredirected_headerr   ri   )rp   r;   r\   r²  r8   r9   r³  å  s   z4Cookies._CookieCompatRequest.add_unredirected_header©r   r,   r2   rk   )r;   r1   r\   r1   r2   rk   )rÌ   rÕ   rÖ   r×   rq   r³  Ú__classcell__r8   r8   r²  r9   r�  ×  s    r�  c                   @  s$   e Zd ZdZddd„Zdd	d
„ZdS )zCookies._CookieCompatResponser°  rT  r-   r2   rk   c                 C  rv   rl   )rT  )rp   rT  r8   r8   r9   rq   ï  rÅ   z&Cookies._CookieCompatResponse.__init__úemail.message.Messagec                 C  s,   t j ¡ }| jj ¡ D ]\}}|||< q|S rl   )rJ   rK   rL   rT  ri   r�   )rp   Úinfor;   rC   r8   r8   r9   r·  ò  s   

z"Cookies._CookieCompatResponse.infoN©rT  r-   r2   rk   )r2   r¶  )rÌ   rÕ   rÖ   r×   rq   r·  r8   r8   r8   r9   r�  é  s    
r�  rl   )rÜ   ræ   r2   rk   r¸  r´  )rR   r“  )
r  r1   rC   r1   r”  r1   r•  r1   r2   rk   )NNN)
r  r1   r“   r=   r”  r=   r•  r=   r2   r=   rÑ   )r  r1   r”  r=   r•  r=   r2   rk   )r”  r=   r•  r=   r2   rk   )r  r1   rC   r1   r2   rk   )r  r1   r2   r1   )r  r1   r2   rk   rÔ   rŠ  r‰  rÒ   )rÌ   rÕ   rÖ   r×   rq   r[  rï   rŒ  r‘   rª  r¨  r¢   r¸   r°   rº   rÄ   r¿   r¯  rÐ   Úurllibr   r,   r�  r�  r8   r8   r8   r9   r*   3  s0    

ûü






r*   )r0   r1   r2   r3   rl   )r;   r<   r0   r=   r2   r>   )rC   r<   r0   r=   r2   r>   )rG   r1   r2   r=   )rC   r1   r2   rP   )ra   rb   r2   rc   )MÚ
__future__r   r4   r~  ÚdatetimeÚemail.messagerJ   rà   rX  rV   rÚ   Úurllib.requestr¹  Úcollections.abcr   r   Úhttp.cookiejarr   r   r   r   r	   r
   r   Ú	_decodersr   r   r   r   r   r   r   Ú_exceptionsr   r   r   r   r   r   r   Z
_multipartr   Z_status_codesr   Ú_typesr   r   r   r   r    r!   r"   r#   r$   r%   r&   Z_urlsr'   Z_utilsr(   r)   Ú__all__re   ÚTypeVarr/   r:   rB   rF   rO   r`   rh   ÚMutableMappingr1   r+   r,   r-   r*   r8   r8   r8   r9   Ú<module>   sN    $$		4




%	       *