
    bj                    (   d dl mZ d dlZd dlmZmZmZmZ d dlm	Z	m
Z
 g dZ G d de          Z ej        d          j        Z G d	 d
eeef                   Z G d de
          Zeeeef         z  eeeef                  z  ez  Z	 ddlmZ dS )    )annotationsN)IterableIteratorMappingMutableMapping)AnyProtocol)HeadersHeadersLikeMultipleValuesErrorc                  $     e Zd ZdZd fdZ xZS )r   zP
    Exception raised when :class:`Headers` has multiple values 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/home/drrone/.local/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   z[\x09\x20-\x7e\x80-\xff]*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d0dZd1dZd& fd Zd2d"Zd3d$Zd.d%Z xZS )4r
   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__I   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>O   s7      JJe#,,,,,JJJJJJr   r/   )joinr%   r   s    r   r   zHeaders.__str__N   s*    wwJJtzJJJJJVSSr   c                0    | j         j         d| j        dS )N())r   r   r%   r6   s    r   __repr__zHeaders.__repr__Q   s     .);;DJ;;;;r   c                    |                                  }| j                                        |_        | j                                        |_        |S r)   )r   r$   copyr%   )r   r<   s     r   r<   zHeaders.copyT   s<    ~~Z__&&
Z__&&
r   bytesc                D    t          |                                           S r)   )r   encoder6   s    r   	serializezHeaders.serializeZ   s    4yy!!!r   r2   objectboolc                b    t          |t                    o|                                | j        v S r)   )
isinstancer   lowerr$   r   r2   s     r   __contains__zHeaders.__contains__`   s&    #s##A		tz(AAr   Iterator[str]c                *    t          | j                  S r)   )iterr$   r6   s    r   __iter__zHeaders.__iter__c   s    DJr   intc                *    t          | j                  S r)   )r   r$   r6   s    r   __len__zHeaders.__len__f   s    4:r   c                    | j         |                                         }t          |          dk    r|d         S t          |          r   )r$   rE   r   r   r   r2   r3   s      r   __getitem__zHeaders.__getitem__k   s<    
399;;'u::??8O%c***r   r3   c                   t          t          |                    st          ||          | j                            |                                g                               |           | j                            ||f           d S r)   )is_valid_header_valuer   InvalidHeaderValuer$   
setdefaultrE   appendr%   rP   s      r   __setitem__zHeaders.__setitem__r   sv    $SZZ00 	1$S%000
ciikk2..55e<<<
3,'''''r   c                    |                                 | j                                       fd| j        D             | _        d S )Nc                N    g | ]!\  }}|                                 k    ||f"S r0   )rE   )r1   kv	key_lowers      r   
<listcomp>z'Headers.__delitem__.<locals>.<listcomp>|   s3    NNNAqwwyyI7M7Mq!f7M7M7Mr   )rE   r$   __delitem__r%   )r   r2   r\   s     @r   r^   zHeaders.__delitem__x   sG    IIKK	
y)))NNNNNNN


r   otherr   c                Z    t          |t                    st          S | j        |j        k    S r)   )rD   r
   NotImplementedr$   )r   r_   s     r   __eq__zHeaders.__eq__~   s)    %)) 	"!!zU[((r   c                "    i | _         g | _        dS )z&
        Remove all headers.

        N)r$   r%   r6   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 r)   )rD   r
   	raw_items)r1   args     r   r4   z!Headers.update.<locals>.<genexpr>   sN       
 
EHz#w77@CMMOOOS
 
 
 
 
 
r   N)tupler   r*   )r   r   r&   r   s      r   r*   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$   getrE   rF   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.

        )rJ   r%   r6   s    r   rg   zHeaders.raw_items   s    
 DJr   c                    | j                             |                                g                               |           | j                            ||f           dS )z=
        Set a header without validating its value.

        N)r$   rU   rE   rV   r%   rP   s      r   set_insecurezHeaders.set_insecure   sR    
 	
ciikk2..55e<<<
3,'''''r   )r   r   r&   r   r   r'   r   )r   r
   )r   r=   )r2   rA   r   rB   )r   rH   )r   rL   r2   r   r   r   )r2   r   r3   r   r   r'   )r2   r   r   r'   )r_   r   r   rB   )r   r'   )r2   r   r   rj   )r   rn   )r   r   r   r    	__slots__r+   r   r:   r<   r@   rG   rK   rN   rQ   rW   r^   rb   rd   r*   rm   rg   rq   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 r)   r0   r6   s    r   keyszSupportsKeysAndGetItem.keys         r   r2   r   c                    d S r)   r0   rF   s     r   rQ   z"SupportsKeysAndGetItem.__getitem__   ry   r   N)r   rv   rr   )r   r   r   r    rx   rQ   r0   r   r   ru   ru      s4         
 )(((//////r   ru   r   )rT   )
__future__r   recollections.abcr   r   r   r   typingr   r	   __all__LookupErrorr   compile	fullmatchrS   r   r
   ru   ri   r   
exceptionsrT   r0   r   r   <module>r      sd   " " " " " " 				 G G G G G G G G G G G G                  
! 
! 
! 
! 
!+ 
! 
! 
! #
#?@@J P( P( P( P( P(nS#X& P( P( P(h0 0 0 0 0X 0 0 0 gc3h(5c?";;>TT  + * * * * * * *r   