
    &thj                    .   d dl mZ d dlZd dlmZmZmZmZmZm	Z	m
Z
mZmZ ej        dd         dk    rd dlmZ neZg dZ G d d	e          Z G d
 de
eef                   Z G d de          Zeee	eef         eeeef                  ef         ZdS )    )annotationsN)	AnyDictIterableIteratorListMappingMutableMappingTupleUnion   )      )Protocol)HeadersHeadersLikeMultipleValuesErrorc                  $     e Zd ZdZd fdZ xZS )r   zT
    Exception raised when :class:`Headers` has more than one value for a key.

    returnstrc                    t          | j                  dk    rt          | j        d                   S t                                                      S N   r   )lenargsreprsuper__str__)self	__class__s    m/var/www/html/mycamper/aliexpress-site/backend/venv/lib/python3.11/site-packages/websockets/datastructures.pyr   zMultipleValuesError.__str__    s>    ty>>Q	!%%%ww       r   r   )__name__
__module____qualname____doc__r   __classcell__r    s   @r!   r   r      sG         
! ! ! ! ! ! ! ! ! !r"   r   c                       e Zd ZdZddgZd%d
Zd&dZd&dZd'dZd(dZ	d)dZ
d*dZd+dZd,dZd-dZd.dZd/dZd0dZd% fd Zd1d"Zd2d$Z xZS )3r   a  
    Efficient data structure for manipulating HTTP headers.

    A :class:`list` of ``(name, values)`` is inefficient for lookups.

    A :class:`dict` doesn't suffice because header names are case-insensitive
    and multiple occurrences of headers with the same name are possible.

    :class:`Headers` stores HTTP headers in a hybrid data structure to provide
    efficient insertions and lookups while preserving the original data.

    In order to account for multiple values with minimal hassle,
    :class:`Headers` follows this logic:

    - When getting a header with ``headers[name]``:
        - if there's no value, :exc:`KeyError` is raised;
        - if there's exactly one value, it's returned;
        - if there's more than one value, :exc:`MultipleValuesError` is raised.

    - When setting a header with ``headers[name] = value``, the value is
      appended to the list of values for that header.

    - When deleting a header with ``del headers[name]``, all values for that
      header are removed (this is slow).

    Other methods for manipulating headers are consistent with this logic.

    As long as no header occurs multiple times, :class:`Headers` behaves like
    :class:`dict`, except keys are lower-cased to provide case-insensitivity.

    Two methods support manipulating multiple values explicitly:

    - :meth:`get_all` returns a list of all values for a header;
    - :meth:`raw_items` returns an iterator of ``(name, values)`` pairs.

    _dict_listr   r   kwargsr   r   Nonec                <    i | _         g | _         | j        |i | d S N)r+   r,   update)r   r   r-   s      r!   __init__zHeaders.__init__P   s-    +-
,.
T$V$$$$$r"   c                P    d                     d | j        D                       dz   S )N c              3  ,   K   | ]\  }}| d | dV  dS )z: 
N ).0keyvalues      r!   	<genexpr>z"Headers.__str__.<locals>.<genexpr>V   s7      JJe#,,,,,JJJJJJr"   r6   )joinr,   r   s    r!   r   zHeaders.__str__U   s*    wwJJtzJJJJJVSSr"   c                0    | j         j         d| j        dS )N())r    r$   r,   r=   s    r!   __repr__zHeaders.__repr__X   s     .);;DJ;;;;r"   c                    |                                  }| j                                        |_        | j                                        |_        |S r0   )r    r+   copyr,   )r   rC   s     r!   rC   zHeaders.copy[   s<    ~~Z__&&
Z__&&
r"   bytesc                D    t          |                                           S r0   )r   encoder=   s    r!   	serializezHeaders.serializea   s    4yy!!!r"   r9   objectboolc                b    t          |t                    o|                                | j        v S r0   )
isinstancer   lowerr+   r   r9   s     r!   __contains__zHeaders.__contains__g   s&    #s##A		tz(AAr"   Iterator[str]c                *    t          | j                  S r0   )iterr+   r=   s    r!   __iter__zHeaders.__iter__j   s    DJr"   intc                *    t          | j                  S r0   )r   r+   r=   s    r!   __len__zHeaders.__len__m   s    4:r"   c                    | j         |                                         }t          |          dk    r|d         S t          |          r   )r+   rL   r   r   r   r9   r:   s      r!   __getitem__zHeaders.__getitem__r   s<    
399;;'u::??8O%c***r"   r:   c                    | j                             |                                g                               |           | j                            ||f           d S r0   )r+   
setdefaultrL   appendr,   rW   s      r!   __setitem__zHeaders.__setitem__y   sP    
ciikk2..55e<<<
3,'''''r"   c                    |                                 | j                                       fd| j        D             | _        d S )Nc                N    g | ]!\  }}|                                 k    ||f"S r7   )rL   )r8   kv	key_lowers      r!   
<listcomp>z'Headers.__delitem__.<locals>.<listcomp>   s3    NNNAqwwyyI7M7Mq!f7M7M7Mr"   )rL   r+   __delitem__r,   )r   r9   ra   s     @r!   rc   zHeaders.__delitem__}   sG    IIKK	
y)))NNNNNNN


r"   otherr   c                Z    t          |t                    st          S | j        |j        k    S r0   )rK   r   NotImplementedr+   )r   rd   s     r!   __eq__zHeaders.__eq__   s)    %)) 	"!!zU[((r"   c                "    i | _         g | _        dS )z&
        Remove all headers.

        N)r+   r,   r=   s    r!   clearzHeaders.clear   s    
 



r"   c                l    t          d |D                       } t                      j        |i | dS )zT
        Update from a :class:`Headers` instance and/or keyword arguments.

        c              3  l   K   | ]/}t          |t                    r|                                n|V  0d S r0   )rK   r   	raw_items)r8   args     r!   r;   z!Headers.update.<locals>.<genexpr>   sN       
 
EHz#w77@CMMOOOS
 
 
 
 
 
r"   N)tupler   r1   )r   r   r-   r    s      r!   r1   zHeaders.update   sS    
  
 
LP
 
 
 
 
 	''''''r"   	List[str]c                \    | j                             |                                g           S )z|
        Return the (possibly empty) list of all values for a header.

        Args:
            key: header name.

        )r+   getrL   rM   s     r!   get_allzHeaders.get_all   s"     z~~ciikk2...r"   Iterator[Tuple[str, str]]c                *    t          | j                  S )zO
        Return an iterator of all values as ``(name, value)`` pairs.

        )rQ   r,   r=   s    r!   rl   zHeaders.raw_items   s    
 DJr"   )r   r   r-   r   r   r.   r#   )r   r   )r   rD   )r9   rH   r   rI   )r   rO   )r   rS   r9   r   r   r   )r9   r   r:   r   r   r.   )r9   r   r   r.   )rd   r   r   rI   )r   r.   )r9   r   r   ro   )r   rs   )r$   r%   r&   r'   	__slots__r2   r   rA   rC   rG   rN   rR   rU   rX   r\   rc   rg   ri   r1   rr   rl   r(   r)   s   @r!   r   r   '   s       # #J '"I% % % %
T T T T< < < <   " " " "B B B B          
+ + + +( ( ( (O O O O) ) ) )
   ( ( ( ( ( (/ / / /               r"   r   c                  "    e Zd ZdZd	dZd
dZdS )SupportsKeysAndGetItemz_
    Dict-like types with ``keys() -> str`` and ``__getitem__(key: str) -> str`` methods.

    r   Iterable[str]c                    d S r0   r7   r=   s    r!   keyszSupportsKeysAndGetItem.keys       r"   r9   r   c                    d S r0   r7   rM   s     r!   rX   z"SupportsKeysAndGetItem.__getitem__   r|   r"   N)r   ry   ru   )r$   r%   r&   r'   r{   rX   r7   r"   r!   rx   rx      sF         
        r"   rx   )
__future__r   systypingr   r   r   r   r   r	   r
   r   r   version_infor   rH   __all__LookupErrorr   r   r   rx   r   r7   r"   r!   <module>r      s   " " " " " " 




 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 BQB6!!H <
;
;
! 
! 
! 
! 
!+ 
! 
! 
!D  D  D  D  D nS#X& D  D  D P
 
 
 
 
X 
 
 
 CHU38_ r"   