o
    ùT·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   úQ/home/dinkstrade/pdmp-scanner/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])Úmatch_type_of)r)   ÚlowerÚSENSITIVE_HEADERSr(   )ra   ÚkÚvr8   r8   r9   Ú_obfuscate_sensitive_headers„   s   €ýri   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   re   Ú	_encoding)Úselfrj   r0   rg   rh   Ú	bytes_keyÚ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)rp   ÚrawÚdecodeÚUnicodeDecodeError)rq   r0   r;   rC   r8   r8   r9   r0   ¨   s   

ÿö	zHeaders.encodingrC   c                 C  ó
   || _ d S rm   )rp   ©rq   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   )Ú.0Úraw_keyÚ_rC   r8   r8   r9   Ú
<listcomp>Ê   ó    zHeaders.raw.<locals>.<listcomp>©rn   ©rq   r8   r8   r9   rv   Å   s   zHeaders.rawútyping.KeysView[str]c                   s   ‡ fdd„ˆ j D ƒ ¡ S )Nc                   s    i | ]\}}}|  ˆ j¡d “qS rm   ©rw   r0   )r~   r€   r;   Ú_valuer„   r8   r9   Ú
<dictcomp>Í   s     z Headers.keys.<locals>.<dictcomp>)rn   Ú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ú, )rn   rw   r0   Úvalues©rq   Úvalues_dictr€   r;   rC   Ústr_keyÚ	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Œ   )rn   rw   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 rm   r8   )rq   r;   r8   r8   r9   Úgetñ   ó   zHeaders.getÚdefaultr/   ústr | _Tc                 C  r—   rm   r8   ©rq   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   )re   rw   r0   )r~   r€   Úitem_keyÚ
item_value©Úget_header_keyrq   r8   r9   r�   	  s
    
þz$Headers.get_list.<locals>.<listcomp>c                 S  s   g | ]}|  ¡ ‘qS r8   )rU   )r~   Úitemr8   r8   r9   r�     s    ú,)re   rA   r0   rn   ÚextendrW   )rq   r;   r    r�   Úsplit_valuesrC   r8   r¤   r9   Úget_list  s   þzHeaders.get_listc                 C  s:   t |ƒ}| ¡ D ]}|| v r|  |¡ q| j |j¡ d S rm   )r+   r‰   Úpoprn   r¨   )rq   rj   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 rm   )r@   r   ÚNotImplementedr­   r¬   ©rq   r®   Úmergedr8   r8   r9   Ú__or__!  ó
   

zHeaders.__or__c                 C  s$   t |tƒstS t|ƒ}| | ¡ |S rm   )r@   r   r°   r+   r¬   r±   r8   r8   r9   Ú__ror__(  r´   zHeaders.__ror__r   c                 C  s   |   |¡ | S rm   )r¬   )rq   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©Únormalized_keyrq   r8   r9   r�   <  s
    
þz'Headers.__getitem__.<locals>.<listcomp>rŒ   )re   rA   r0   rn   ÚjoinrŸ   )rq   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.
        ru   c                   s"   g | ]\}\}}}|ˆ kr|‘qS r8   r8   ©r~   Úidxr€   r¢   ©Ú
lookup_keyr8   r9   r�   P  ó   " z'Headers.__setitem__.<locals>.<listcomp>r   Nr   )rA   rp   re   Ú	enumeratern   ÚreversedrY   )rq   r;   rC   Úset_keyÚ	set_valueÚ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   )re   r½   ©Údel_keyr8   r9   r�   a  s   & z'Headers.__delitem__.<locals>.<listcomp>N)re   rA   r0   rÂ   rn   rŸ   rÃ   )rq   r;   Ú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>)re   rA   r0   rn   )rq   r;   r·   r8   r8   r9   Ú__contains__i  s   zHeaders.__contains__útyping.Iterator[typing.Any]c                 C  s   t |  ¡ ƒS rm   )Úiterr‰   r„   r8   r8   r9   Ú__iter__m  ó   zHeaders.__iter__Úintc                 C  ó
   t | jƒS rm   )Úlenrn   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   rn   Úsorted)rq   r®   Úother_headersÚ	self_listÚ
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   ro   ri   r–   ÚdictrÔ   )rq   Ú
class_nameÚencoding_strÚas_listÚas_dictÚno_duplicate_keysr8   r8   r9   Ú__repr__}  s   
zHeaders.__repr__©NN)rj   rk   r0   r=   r2   rl   ©r2   r1   ©rC   r1   r2   rl   )r2   r|   )r2   r…   )r2   rŠ   )r2   r’   )r2   r“   )r;   r1   r2   r=   )r;   r1   rš   r/   r2   r›   rm   )r;   r1   rš   r�   r2   rž   )F)r;   r1   r    r3   r2   r¡   )rj   rk   r2   rl   )r2   r+   )r®   r¯   r2   r+   )r®   r   r2   r+   )r;   r1   r2   r1   )r;   r1   rC   r1   r2   rl   )r;   r1   r2   rl   )r;   rÌ   r2   r3   )r2   rÎ   ©r2   rÒ   )r®   rÌ   r2   r3   )rà   Ú
__module__Ú__qualname__Ú__doc__rt   Úpropertyr0   Úsetterrv   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]   rj   ÚcookiesÚcontentÚdataÚfilesÚjsonÚstreamÚ
extensionsÚmethodr1   rS   ú	URL | strr]   úQueryParamTypes | Nonerj   rk   ró   úCookieTypes | Nonerô   úRequestContent | Nonerõ   úRequestData | Nonerö   úRequestFiles | Noner÷   útyping.Any | Nonerø   ú'SyncByteStream | AsyncByteStream | Nonerù   úRequestExtensions | Noner2   rl   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+   rj   rá   rù   r*   Úset_cookie_headerr˜   r
   r   rA   r0   Ú_preparerø   r@   r   Úread)rq   rú   rS   r]   rj   ró   rô   rõ   rö   r÷   rø   rù   rG   r8   r8   r9   rt   Ž  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ÚPATCHÚQUERY)s   Content-Lengthó   0)ra   re   rj   Ú
setdefaultrS   ÚhostrY   Únetlocrú   r+   rv   )rq   r	  r;   rC   Úauto_headersÚhas_hostÚ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 rm   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ú   )rq   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 rm   )ra   Úsetattrrù   r	   rø   ©rq   r1  r,  rC   r8   r8   r9   Ú__setstate__  s   zRequest.__setstate__)rú   r1   rS   rû   r]   rü   rj   rk   ró   rý   rô   rþ   rõ   rÿ   rö   r   r÷   r  rø   r  rù   r  r2   rl   ©r	  r
  r2   rl   ©r2   r>   ré   ©r2   r(  ©r1  r(  r2   rl   )rà   rì   rí   rt   r  rï   rô   r  r&  rç   r/  r4  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-   Nru   )
rj   rô   ÚtextÚhtmlr÷   rø   Úrequestrù   ÚhistoryÚdefault_encodingÚstatus_coderÒ   rj   rk   rô   úResponseContent | Noner9  r=   r:  r÷   rÌ   rø   r  r;  úRequest | Nonerù   úResponseExtensions | Noner<  úlist[Response] | Noner=  ú*str | typing.Callable[[bytes], str | None]r2   rl   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+   rj   Ú_requestÚnext_requestrá   rù   ro   r<  Ú	is_closedÚis_stream_consumedr=  r   r  rø   r@   r   r  Ú_num_bytes_downloaded)rq   r>  rj   rô   r9  r:  r÷   rø   r;  rù   r<  r=  r8   r8   r9   rt     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   re   rj   r  )rq   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ø   ÚRuntimeErrorrJ  )rq   Ústream_elapsedr8   r8   r9   rK  L  s   
zResponse.elapsedrK  c                 C  ry   rm   )rJ  )rq   rK  r8   r8   r9   rK  Y  r{   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.)rD  rM  r„   r8   r8   r9   r;  ]  s   
zResponse.requestrC   c                 C  ry   rm   )rD  rz   r8   r8   r9   r;  f  r{   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Ÿ   rw   )rq   rO  r8   r8   r9   rO  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?   rP  rQ  )rù   rŸ   r   Úget_reason_phraser>  rw   )rq   rS  r8   r8   r9   rS  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   ru   r7   )r  rô   rU  r   r0   r»   rw   Úflush)rq   rô   Údecoderr8   r8   r9   r9  ‰  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.
        rp   Nr  ru   )r  Úcharset_encodingr:   r@   r=  r1   r  rp   )rq   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.
        rU  z?Setting encoding after `text` has been accessed is not allowed.N)r  rX   rp   rz   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)rj   r˜   rO   )rq   rG   r8   r8   r9   rX  ¶  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   re   )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�   É  rZ  r   r   )r  rj   rª   r   rÔ   ÚchildrenrY  r   )rq   r�   Ú	encodingsrW  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   r`  Ó  ó   zResponse.is_informationalc                 C  r_  )zU
        A property which is `True` for 2xx status codes, `False` otherwise.
        )r   Ú
is_successr>  r„   r8   r8   r9   rb  Ú  ra  zResponse.is_successc                 C  r_  )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   rc  á  s   
zResponse.is_redirectc                 C  r_  )zU
        A property which is `True` for 4xx status codes, `False` otherwise.
        )r   Úis_client_errorr>  r„   r8   r8   r9   rd  í  ra  zResponse.is_client_errorc                 C  r_  )zU
        A property which is `True` for 5xx status codes, `False` otherwise.
        )r   Úis_server_errorr>  r„   r8   r8   r9   re  ô  ra  zResponse.is_server_errorc                 C  r_  )z]
        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
        )r   Úis_errorr>  r„   r8   r8   r9   rf  û  ra  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.
        ÚLocation)r>  r   ÚMOVED_PERMANENTLYÚFOUNDÚ	SEE_OTHERÚTEMPORARY_REDIRECTÚPERMANENT_REDIRECTrj   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)rD  rM  rb  rm  r>  r˜   Úformatr   )rq   r;  rK   Ústatus_classÚerror_typesrr  r8   r8   r9   Úraise_for_status  s*   ÿÿÿ
üzResponse.raise_for_statusÚkwargsc                 K  s   t j| jfi |¤ŽS rm   )ÚjsonlibÚloadsrô   )rq   rx  r8   r8   r9   r÷   =  r0  zResponse.jsonr*   c                 C  s$   t | dƒstƒ | _| j | ¡ | jS )NÚ_cookies)r  r*   r{  Ú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>)rj   r˜   r`   )rq   Úheaderr8   r8   r9   rZ   G  s   zResponse.linksc                 C  s   | j S rm   )rH  r„   r8   r8   r9   Únum_bytes_downloadedR  s   zResponse.num_bytes_downloadedc                 C  s   d| j › d| j› d�S )Nz<Response [ú ú]>)r>  rS  r„   r8   r8   r9   rç   V  s   zResponse.__repr__r(  c                 C  r)  )Nc                 S  r*  ))rù   rø   rF  rY  r8   r+  r8   r8   r9   rˆ   Z  s
    þz)Response.__getstate__.<locals>.<dictcomp>r-  r„   r8   r8   r9   r/  Y  s   þzResponse.__getstate__r1  c                 C  s6   |  ¡ D ]
\}}t| ||ƒ qd| _i | _tƒ | _d S )NT)ra   r2  rF  rù   r	   rø   r3  r8   r8   r9   r4  `  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   ©r…  ©r;  )r  rÔ   r  ÚrangeÚmaxr^  r   r   rD  Úiter_rawrw   rV  )rq   r…  ÚirW  ÚchunkerÚ	raw_bytesÚdecodedÚchunkr8   r8   r9   r„  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.
        ru   r7   r‰  rŠ  N)r   r0   r   r   rD  r„  rw   rV  ©rq   r…  rW  r�  Úbyte_contentÚtext_contentr’  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 ©NrŠ  )r   r   rD  r˜  rw   rV  ©rq   rW  r9  Ú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   r‰  rŠ  N)rG  r   rF  r   r@   rø   r&   rM  rH  r   r   rD  rÔ   rw   rV  Úclose)rq   r…  r�  Úraw_stream_bytesr’  r8   r8   r9   r�  ¢  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.TrŠ  N)r@   rø   r&   rM  rF  r   rD  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 )rƒ  r  Nr  c                 Ó  r!  rm   r8   r"  r8   r8   r9   r�   Ð  r$  z"Response.aread.<locals>.<listcomp>)r  Ú
contextlibÚaclosingÚaiter_bytesr»   r  )rq   Ú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 rˆ  )r  rÔ   r  r‹  rŒ  r^  r   r   rD  r¡  r¢  Ú	aiter_rawrw   rV  )	rq   r…  rŽ  rW  r�  Ú
raw_streamr�  r‘  r’  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 r”  )r   r0   r   r   rD  r£  rw   rV  r•  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 r™  )r   r   rD  r©  rw   rV  rš  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 )r�  z5Attempted to call an async iterator on a sync stream.Tr   r‰  rŠ  N)rG  r   rF  r   r@   rø   r   rM  rH  r   Ú	__aiter__r   rD  rÔ   rw   rV  r   Úaclose)rq   r…  r�  rø   rŸ  r’  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.TrŠ  N)r@   rø   r   rM  rF  r   rD  r¬  r„   r8   r8   r9   r¬  %  s   €"ÿþzResponse.aclose)r>  rÒ   rj   rk   rô   r?  r9  r=   r:  r=   r÷   rÌ   rø   r  r;  r@  rù   rA  r<  rB  r=  rC  r2   rl   r5  )r2   rI  )rK  rI  r2   rl   )r2   r,   )rC   r,   r2   rl   ré   )r2   r'   r6  )r2   r=   rê   )r2   r   ©r2   r3   )r2   r-   )rx  rÌ   r2   rÌ   )r2   r*   )r2   r}  rë   r7  r8  rm   )r…  r†  r2   r‡  )r…  r†  r2   r“  ©r2   r“  )r2   rl   )r…  r†  r2   r¥  )r…  r†  r2   r¨  )r2   r¨  ),rà   rì   rí   rt   r  rï   rK  rð   r;  rO  rS  rS   rô   r9  r0   rX  r^  r`  rb  rc  rd  re  rf  rm  rw  r÷   ró   rZ   r€  rç   r/  r4  r  r„  r˜  rœ  r�  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   rl   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 rm   )	r@   rá   r   Újarra   Úsetro   r*   Ú
set_cookie)rq   ró   r;   rC   Úcookier8   r8   r9   rt   8  s$   
þ
ÿ

ÿ
zCookies.__init__rs  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)rj   Ú_CookieCompatResponseÚ_CookieCompatRequestr;  r¯  r|  )rq   rs  Ú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)rq   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±  )rq   r,  rC   r¹  rº  rx  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   )rq   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 rm   )r,  r¹  rº  ©r~   r²  ©r¹  r,  rº  r8   r9   r�   œ  s    
üz"Cookies.delete.<locals>.<listcomp>)r¯  Úclearr¹  rº  r,  )rq   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Í  )rq   r¹  rº  Úargsr8   r8   r9   rÍ  §  s   

zCookies.clearc                 C  s$   t |ƒ}|jD ]}| j |¡ qd S rm   )r*   r¯  r±  )rq   ró   r²  r8   r8   r9   r¬   ´  s   
ÿzCookies.updatec                 C  s   |   ||¡S rm   )r°  ©rq   r,  rC   r8   r8   r9   rÇ   ¹  rÑ   zCookies.__setitem__c                 C  s   |   |¡}|d u rt|ƒ‚|S rm   )r˜   rŸ   rÑ  r8   r8   r9   r¼   ¼  s   
zCookies.__getitem__c                 C  s
   |   |¡S rm   )rÏ  )rq   r,  r8   r8   r9   rË   Â  rÖ   zCookies.__delitem__rÒ   c                 C  rÓ   rm   )rÔ   r¯  r„   r8   r8   r9   rÕ   Å  rÖ   zCookies.__len__r“  c                 C  r}   )Nc                 s  s   � | ]}|j V  qd S rm   )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Ó  )rq   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[r‚  )r»   r¯  )rq   Ú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   rl   c                   s*   t ƒ jt|jƒt|jƒ|jd� || _d S )N)rS   rj   rú   )Úsuperrt   r1   rS   rá   rj   rú   r;  )rq   r;  ©rß   r8   r9   rt   Ý  s   ý
z%Cookies._CookieCompatRequest.__init__r;   r1   r\   c                   s   t ƒ  ||¡ || jj|< d S rm   )r×  Úadd_unredirected_headerr;  rj   )rq   r;   r\   rØ  r8   r9   rÙ  å  s   z4Cookies._CookieCompatRequest.add_unredirected_header©r;  r,   r2   rl   )r;   r1   r\   r1   r2   rl   )rà   rì   rí   rî   rt   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Ö  rs  r-   r2   rl   c                 C  ry   rm   )rs  )rq   rs  r8   r8   r9   rt   ï  rÖ   z&Cookies._CookieCompatResponse.__init__úemail.message.Messagec                 C  s,   t j ¡ }| jj ¡ D ]\}}|||< q|S rm   )rJ   rK   rL   rs  rj   r–   )rq   Úinfor;   rC   r8   r8   r9   rÝ  ò  s   

z"Cookies._CookieCompatResponse.infoN©rs  r-   r2   rl   )r2   rÜ  )rà   rì   rí   rî   rt   rÝ  r8   r8   r8   r9   r³  é  s    
r³  rm   )ró   rý   r2   rl   rÞ  rÚ  )rR   r¸  )
r,  r1   rC   r1   r¹  r1   rº  r1   r2   rl   )NNN)
r,  r1   rš   r=   r¹  r=   rº  r=   r2   r=   rè   )r,  r1   r¹  r=   rº  r=   r2   rl   )r¹  r=   rº  r=   r2   rl   )r,  r1   rC   r1   r2   rl   )r,  r1   r2   r1   )r,  r1   r2   rl   rë   r®  r­  ré   )rà   rì   rí   rî   rt   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   rm   )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÷   ry  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   Ú
_multipartr   Ú_status_codesr   Ú_typesr   r   r   r   r    r!   r"   r#   r$   r%   r&   Ú_urlsr'   Ú_utilsr(   r)   Ú__all__rf   ÚTypeVarr/   r:   rB   rF   rO   r`   ri   ÚMutableMappingr1   r+   r,   r-   r*   r8   r8   r8   r9   Ú<module>   sN    $$		4




%	       *