
    F2jY                    >   d dl mZ d dlZd dlmZ d dlmZ d dlm	Z	m
Z
 d dlmZ d dlmZ ej        rd dlmZ  G d	 d
e          Zg dZ ej        d          Z ej        d          Z ej        d          Zej        dej        eef         ej        ej        eef                  d
f         Z G d de	          Z ed          d(d            Zd)dZ G d dej         eef         ej!        eef                   Z" G d dej#        ej        eef                            Z$ G d  dej!        eef                   Z% ej        d!ej&        "          Z' ej        d#          Z( G d$ d%ej)        e'                   Z* G d& d'ej+        e'e(f                   Z,dS )*    )annotationsN)OrderedDict)Mapping)Enumauto)	lru_cache)RLock)Protocolc                      e Zd ZddZd	dZdS )
HasGettableStringKeysreturntyping.Iterator[str]c                    d S N selfs    \/home/thesage/.hermes/hermes-agent/venv/lib/python3.11/site-packages/urllib3/_collections.pykeyszHasGettableStringKeys.keys             keystrc                    d S r   r   r   r   s     r   __getitem__z!HasGettableStringKeys.__getitem__   r   r   Nr   r   r   r   r   r   )__name__
__module____qualname__r   r   r   r   r   r   r      s(        3333333333r   r   )RecentlyUsedContainerHTTPHeaderDictGroupedDict_KT_VT_DTr#   c                  "    e Zd Z e            ZdS )	_SentinelN)r   r    r!   r   
not_passedr   r   r   r)   r)   +   s        JJJr   r)   @   )maxsizestringr   r   c                *    |                                  S )zjReasoning: We are often calling lower on repetitive identical header key. This was unnecessary exhausting!)lower)r-   s    r   _lower_wrapperr0   /   s     <<>>r   	potentialobjectValidHTTPHeaderSource | Nonec                   t          | t                    r| S t          | t          j                  r1t          j        t          j        t
          t
          f         |           S t          | t          j                  rAt          j        t          j        t          j        t
          t
          f                  |           S t          | d          r%t          | d          rt          j        d|           S d S )Nr   r   r   )	
isinstancer#   typingr   castr   IterableTuplehasattr)r1   s    r   %ensure_can_construct_http_header_dictr;   5   s     )^,, 	Iv~	.	.  {6>#s(3Y???	Iv	/	/  {6?6<S+ABINNN	F	#	# 	=(I(I {2I>>>tr   c                       e Zd ZU dZded<   ded<   ded<   ded	<   	 	 dd fdZddZd dZd!dZd"dZ	d#dZ
d$dZd%dZ xZS )&r"   a^  
    Provides a thread-safe dict-like container which maintains up to
    ``maxsize`` keys while throwing away the least-recently-used keys beyond
    ``maxsize``. Caution: RecentlyUsedContainer is deprecated and scheduled for
    removal in a next major of urllib3.future. It has been replaced by a more
    suitable implementation in ``urllib3.util.traffic_police``.

    :param maxsize:
        Maximum number of recent elements to retain.

    :param dispose_func:
        Every time an item is evicted from the container,
        ``dispose_func(value)`` is called.  Callback which will get called
    ztyping.OrderedDict[_KT, _VT]
_containerint_maxsize#typing.Callable[[_VT], None] | Nonedispose_funcr	   lock
   Nr,   r   Nonec                    t                                                       || _        || _        t	                      | _        t                      | _        d S r   )super__init__r?   rA   r   r=   r	   rB   )r   r,   rA   	__class__s      r   rG   zRecentlyUsedContainer.__init__^   sD    
 	(%--GG			r   r   r%   r&   c                    | j         5  | j                            |          }|| j        |<   |cd d d            S # 1 swxY w Y   d S r   )rB   r=   pop)r   r   items      r   r   z!RecentlyUsedContainer.__getitem__i   s    Y 	 	?&&s++D#'DOC 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	   &;??valuec                   d }| j         5  	 || j                            |          f}|| j        |<   nR# t          $ rE || j        |<   t	          | j                  | j        k    r| j                            d          }Y nw xY wd d d            n# 1 swxY w Y   |#| j        r|\  }}|                     |           d S d S d S )NF)last)rB   r=   rJ   KeyErrorlenr?   popitemrA   )r   r   rM   evicted_item_evicted_values         r   __setitem__z!RecentlyUsedContainer.__setitem__p   sH   Y 	G 	GG  #DO$7$7$<$<<',$$ G G G (-$t''$-77 $(?#:#:#:#F#FLG	G 	G 	G 	G 	G 	G 	G 	G 	G 	G 	G 	G 	G 	G 	G& #(9#+A}m,,,,, $###s2   B&3BAB?BBBBBc                    | j         5  | j                            |          }d d d            n# 1 swxY w Y   | j        r|                     |           d S d S r   )rB   r=   rJ   rA   )r   r   rM   s      r   __delitem__z!RecentlyUsedContainer.__delitem__   s    Y 	- 	-O'',,E	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	-  	%e$$$$$	% 	%s   /33c                l    | j         5  t          | j                  cd d d            S # 1 swxY w Y   d S r   )rB   rQ   r=   r   s    r   __len__zRecentlyUsedContainer.__len__   s{    Y 	( 	(t''	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s   )--typing.NoReturnc                     t          d          )Nz7Iteration over this class is unlikely to be threadsafe.)NotImplementedErrorr   s    r   __iter__zRecentlyUsedContainer.__iter__   s    !E
 
 	
r   c                   | j         5  t          | j                                                  }| j                                         d d d            n# 1 swxY w Y   | j        r|D ]}|                     |           d S d S r   )rB   listr=   valuesclearrA   )r   ra   rM   s      r   rb   zRecentlyUsedContainer.clear   s    Y 	$ 	$$/002233FO!!###	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$ 	$
  	) ) )!!%((((	) 	)) )s   A AAAset[_KT]c                    | j         5  t          | j                                                  cd d d            S # 1 swxY w Y   d S r   )rB   setr=   r   r   s    r   r   zRecentlyUsedContainer.keys   s    Y 	/ 	/t++--..	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/rL   )rC   N)r,   r>   rA   r@   r   rD   )r   r%   r   r&   )r   r%   rM   r&   r   rD   )r   r%   r   rD   r   r>   )r   r[   r   rD   )r   rc   )r   r    r!   __doc____annotations__rG   r   rV   rX   rZ   r^   rb   r   __classcell__rH   s   @r   r"   r"   I   s          -,,,MMM5555KKK <@	 	 	 	 	 	 	   - - - -2% % % %( ( ( (
 
 
 

) ) ) )/ / / / / / / /r   r"   c                  >    e Zd ZU dZded<   ddZdd	ZddZddZdS )HTTPHeaderDictItemViewa  
    HTTPHeaderDict is unusual for a Mapping[str, str] in that it has two modes of
    address.

    If we directly try to get an item with a particular name, we will get a string
    back that is the concatenated version of all the values:

    >>> d['X-Header-Name']
    'Value1, Value2, Value3'

    However, if we iterate over an HTTPHeaderDict's items, we will optionally combine
    these values based on whether combine=True was called when building up the dictionary

    >>> d = HTTPHeaderDict({"A": "1", "B": "foo"})
    >>> d.add("A", "2", combine=True)
    >>> d.add("B", "bar")
    >>> list(d.items())
    [
        ('A', '1, 2'),
        ('B', 'foo'),
        ('B', 'bar'),
    ]

    This class conforms to the interface required by the MutableMapping ABC while
    also giving us the nonstandard iteration behavior we want; items with duplicate
    keys, ordered by time of first insertion.
    r#   _headersheadersr   rD   c                    || _         d S r   )rn   )r   ro   s     r   rG   zHTTPHeaderDictItemView.__init__   s    r   r>   c                h    t          t          | j                                                            S r   )rQ   r`   rn   	iteritemsr   s    r   rZ   zHTTPHeaderDictItemView.__len__   s&    4//1122333r    typing.Iterator[tuple[str, str]]c                4    | j                                         S r   )rn   rr   r   s    r   r^   zHTTPHeaderDictItemView.__iter__   s    }&&(((r   rK   r2   boolc                    t          |t                    r]t          |          dk    rJ|\  }}t          |t                    r0t          |t                    r| j                            ||          S dS )N   F)r5   tuplerQ   r   rn   _has_value_for_header)r   rK   
passed_key
passed_vals       r   __contains__z#HTTPHeaderDictItemView.__contains__   so    dE"" 	Ss4yyA~~%)"J
*c** Sz*c/J/J S}:::zRRRur   N)ro   r#   r   rD   rf   r   rs   )rK   r2   r   ru   )	r   r    r!   rh   ri   rG   rZ   r^   r|   r   r   r   rm   rm      s~          8        4 4 4 4) ) ) )     r   rm   c                  @    e Zd ZU dZded<   d8d9 fd	Zd:dZd;dZd<dZd=dZ	d>d? fdZ
d@dZd@dZdAdZdBdZd<dZdd dCd"ZdDd%Zej        dEd'            Zej        dFd*            Zej        fdGd,ZeZeZeZeZdHd-ZdId.ZdJd/ZdKd1ZdKd2ZdLd4Z dMd7Z! xZ"S )Nr#   ap  
    :param headers:
        An iterable of field-value pairs. Must not contain multiple field names
        when compared case-insensitively.

    :param kwargs:
        Additional field-value pairs to pass in to ``dict.update``.

    A ``dict`` like container for storing HTTP Headers.

    Field names are stored and compared case-insensitively in compliance with
    RFC 7230. Iteration provides the first case-sensitive key seen for each
    case-insensitive pair.

    Using ``__setitem__`` syntax overwrites fields that compare equal
    case-insensitively in order to maintain ``dict``'s api. For fields that
    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
    in a loop.

    If multiple fields that are equal case-insensitively are passed to the
    constructor or ``.update``, the behavior is undefined and some will be
    lost.

    >>> headers = HTTPHeaderDict()
    >>> headers.add('Set-Cookie', 'foo=bar')
    >>> headers.add('set-cookie', 'baz=quxx')
    >>> headers['content-length'] = '7'
    >>> headers['SET-cookie']
    'foo=bar, baz=quxx'
    >>> headers['Content-Length']
    '7'
    z%typing.MutableMapping[str, list[str]]r=   Nro   r3   kwargsr   c                   t                                                       i | _        |@t          |t                    r|                     |           n|                     |           |r|                     |           d S d S r   )rF   rG   r=   r5   r#   
_copy_fromextend)r   ro   r   rH   s      r   rG   zHTTPHeaderDict.__init__   s    '>22 %((((G$$$ 	 KK	  	 r   r   valr   rD   c                8    ||g| j         t          |          <   d S r   r=   r0   r   r   r   s      r   rV   zHTTPHeaderDict.__setitem__  s     03Szs++,,,r   c                    t          |t                    r|                    d          }| j        t	          |                   }d                    |dd                    S )Nlatin-1,    )r5   bytesdecoder=   r0   joinr   s      r   r   zHTTPHeaderDict.__getitem__  sS    c5!! 	(**Y''ConS112yyQRR!!!r   c                    t          |t                    r|                    d          }| j        t	          |          = d S )Nr   )r5   r   r   r=   r0   r   s     r   rX   zHTTPHeaderDict.__delitem__  s=    c5!! 	(**Y''CON3//000r   r2   ru   c                    t          |t                    r|                    d          }t          |t                    rt	          |          | j        v S dS )Nr   F)r5   r   r   r   r0   r=   r   s     r   r|   zHTTPHeaderDict.__contains__  sQ    c5!! 	(**Y''Cc3 	:!#&&$/99ur    defaultc                H    t                                          ||          S r   )rF   
setdefaultr   r   r   rH   s      r   r   zHTTPHeaderDict.setdefault  s    ww!!#w///r   otherc                    t          |          }|dS  t          |           |          }d |                                 D             d |                                D             k    S )NFc                4    i | ]\  }}t          |          |S r   r0   .0kvs      r   
<dictcomp>z)HTTPHeaderDict.__eq__.<locals>.<dictcomp>'  s&    CCCAq!!1CCCr   c                4    i | ]\  }}t          |          |S r   r   r   s      r   r   z)HTTPHeaderDict.__eq__.<locals>.<dictcomp>'  s9     H
 H
 H
%)QN1qH
 H
 H
r   )r;   type
itermerged)r   r   maybe_constructableother_as_http_header_dicts       r   __eq__zHTTPHeaderDict.__eq__   s    CEJJ&5(2T

3F(G(G%CC1B1BCCC H
 H
-F-Q-Q-S-SH
 H
 H
 
 	
r   c                .    |                      |           S r   )r   )r   r   s     r   __ne__zHTTPHeaderDict.__ne__+  s    ;;u%%%%r   r>   c                *    t          | j                  S r   )rQ   r=   r   s    r   rZ   zHTTPHeaderDict.__len__.  s    4?###r   r   c              #  V   K   | j                                         D ]}|d         V  d S Nr   )r=   ra   )r   valss     r   r^   zHTTPHeaderDict.__iter__1  s<      O**,, 	 	Dq'MMMM	 	r   c                0    	 | |= d S # t           $ r Y d S w xY wr   )rP   r   s     r   discardzHTTPHeaderDict.discard6  s4    	S			 	 	 	DD	s    
F)combiner   c                   t          |          }||g}| j                            ||          }||ur,|r|d         dz   |z   |d<   dS |                    |           dS dS )a  Adds a (name, value) pair, doesn't overwrite the value if it already
        exists.

        If this is called with combine=True, instead of adding a new header value
        as a distinct item during iteration, this will instead append the value to
        any existing header value with a comma. If no existing header value exists
        for the key, then the value will simply be added, ignoring the combine parameter.

        >>> headers = HTTPHeaderDict(foo='bar')
        >>> headers.add('Foo', 'baz')
        >>> headers['foo']
        'bar, baz'
        >>> list(headers.items())
        [('foo', 'bar'), ('foo', 'baz')]
        >>> headers.add('foo', 'quz', combine=True)
        >>> list(headers.items())
        [('foo', 'bar, baz, quz')]
        r   N)r0   r=   r   append)r   r   r   r   	key_lowernew_valsr   s          r   addzHTTPHeaderDict.add<  s    & #3''	:)))X>>4  !8d?S0RC       r   argsValidHTTPHeaderSourcec                @   t          |          dk    r t          dt          |           d          t          |          dk    r|d         nd}t          |t                    r1|                                D ]\  }}|                     ||           nt          |t          j                  r1|                                D ]\  }}|                     ||           nt          |t          j	                  r|D ]\  }}|                     ||           nSt          |d          rCt          |d          r3|                                D ]}|                     |||                    |                                D ]\  }}|                     ||           dS )	zGeneric import function for any type of header-like object.
        Adapted version of MutableMapping.update in order to insert items
        with self.add instead of self.__setitem__
        r   z/extend() takes at most 1 positional arguments (z given)r   r   r   r   N)rQ   	TypeErrorr5   r#   rr   r   r6   r   itemsr8   r:   r   )r   r   r   r   r   r   rM   s          r   r   zHTTPHeaderDict.extend[  s   
 t99q==T#d))TTT   t99>>Qre^,, 	*!OO-- # #Sc""""#v~.. 	*!KKMM # #Sc""""#v// 
	*# % %
Ue$$$$%UF## 	*}(E(E 	* zz|| * *eCj)))) ,,.. 	! 	!JCHHS%    	! 	!r   	list[str]c                    d S r   r   r   s     r   getlistzHTTPHeaderDict.getlist{  s    .1cr   r'   list[str] | _DTc                    d S r   r   )r   r   r   s      r   r   zHTTPHeaderDict.getlist~  s    BE#r   _Sentinel | _DTc                    t          |t                    r|                    d          }	 | j        t	          |                   }|dd         S # t
          $ r |t          j        u rg cY S |cY S w xY w)zmReturns a list of all the values for the named field. Returns an
        empty list if the key doesn't exist.r   r   N)r5   r   r   r=   r0   rP   r)   r*   )r   r   r   r   s       r   r   zHTTPHeaderDict.getlist  s    
 c5!! 	(**Y''C	?>##6#67D 8O  	 	 	)...			NNN	s   A A1,A10A1c                t    t          |           j         dt          |                                            dS )N())r   r   dictr   r   s    r   __repr__zHTTPHeaderDict.__repr__  s4    t**%BBT__->->(?(?BBBBr   c                n    |D ]1}|                     |          }|g|| j        t          |          <   2d S r   )r   r=   r0   )r   r   r   r   s       r   r   zHTTPHeaderDict._copy_from  sI     	? 	?C--$$C47;#;DON3//00	? 	?r   c                ^     t          |                       }|                    |            |S r   )r   r   )r   clones     r   copyzHTTPHeaderDict.copy  s,    T

r   rs   c              #  z   K   | D ]5}| j         t          |                   }|dd         D ]}|d         |fV  6dS )z8Iterate over all header lines, including duplicate ones.r   Nr   r   )r   r   r   r   s       r   rr   zHTTPHeaderDict.iteritems  sf       	# 	#C?>##6#67DABBx # #1gsl""""#	# 	#r   c              #     K   | D ]C}| j         t          |                   }|d         d                    |dd                   fV  DdS )z:Iterate over all headers, merging duplicate ones together.r   r   r   N)r=   r0   r   r   s      r   r   zHTTPHeaderDict.itermerged  s_       	- 	-C/."5"56Ca&$))CG,,,,,,,	- 	-r   rm   c                     t          |           S r   )rm   r   s    r   r   zHTTPHeaderDict.items  s    %d+++r   header_namepotential_valuec                V    || v r$|| j         t          |                   dd          v S dS )Nr   Fr   )r   r   r   s      r   ry   z$HTTPHeaderDict._has_value_for_header  s8    $"don[6Q6Q&RSTSUSU&VVVur   r   )ro   r3   r   r   )r   r   r   r   r   rD   r   )r   r   r   rD   r   r2   r   ru   )r   )r   r   r   r   r   r   )r   r2   r   ru   rf   r   )r   r   r   r   r   ru   r   rD   )r   r   r   r   r   rD   )r   r   r   r   )r   r   r   r'   r   r   )r   r   r   r   r   r   r   r   )r   r#   r   rD   )r   r#   r}   )r   rm   )r   r   r   r   r   ru   )#r   r    r!   rh   ri   rG   rV   r   rX   r|   r   r   r   rZ   r^   r   r   r   r6   overloadr   r)   r*   
getheadersgetallmatchingheadersigetget_allr   r   r   rr   r   r   ry   rj   rk   s   @r   r#   r#      sh         B 6555	  	  	  	  	  	  	 : : : :" " " "1 1 1 1
   0 0 0 0 0 0 0	
 	
 	
 	
& & & &$ $ $ $   
    :? ! ! ! ! ! !>! ! ! !@ _111 _1_EEE _E 4=3G    * J#D GC C C C? ? ? ?
   
# # # #- - - -, , , ,       r   _GK)bound_GVc                  >    e Zd ZdZdZddZdd	ZddZddZddZ	dS )ReverseKeysViewaN  A read-only ``KeysView`` over the keys mapped to a single value.

    Returned by :meth:`GroupedDict.keys_for`. Backed by reference to an
    internal bucket so the view is live (mirrors ``dict.keys()`` semantics):
    subsequent mutations of the parent :class:`GroupedDict` are reflected on
    next iteration / membership test.
    _bucketbucket typing.Optional[typing.Set[_GK]]r   rD   c                    || _         d S r   r   )r   r   s     r   rG   zReverseKeysView.__init__  s     :@r   typing.Iterator[_GK]c                V    | j         t          d          S t          | j                   S )Nr   )r   iterr   s    r   r^   zReverseKeysView.__iter__  s%    <88ODL!!!r   r>   c                <    | j         dS t          | j                   S r   )r   rQ   r   s    r   rZ   zReverseKeysView.__len__  s    <14<   r   r   r2   ru   c                &    | j         dS || j         v S )NFr   r   s     r   r|   zReverseKeysView.__contains__  s    <5dl""r   r   c                R    d| j         rt          |           nt                      dS )NzReverseKeysView(r   )r   re   r   s    r   r   zReverseKeysView.__repr__  s(    Kt|"F#d)))KKKKr   N)r   r   r   rD   )r   r   rf   r   r   )
r   r    r!   rh   	__slots__rG   r^   rZ   r|   r   r   r   r   r   r     s          I@ @ @ @
" " " "
! ! ! !
# # # #
L L L L L Lr   r   c                       e Zd ZdZdZddd# fdZd$ fdZd% fdZd& fdZd' fdZ	d( fdZ
d)d* fdZd+dZd,dZd-dZd-dZe	 d)d.d"            Z xZS )/r$   uu  A ``dict`` subclass that maintains a reverse "value to keys" index.

    Optimized for the case where many keys share a small number of distinct
    values. Reverse lookups via :meth:`keys_for` are O(1) average time and
    return a live :class:`ReverseKeysView`.

    A ``key_fn`` may be supplied to control how values are hashed for the
    reverse index. By default, the value itself is used (identity over
    equality). Pass ``key_fn=id`` to index by object identity instead — this
    is the right choice when values may override ``__eq__`` / ``__hash__``
    in ways you don't want to collapse buckets on, or when values are not
    hashable themselves.

    All standard ``dict`` mutation entry points are overridden to keep the
    reverse index coherent. Empty buckets are pruned eagerly so that
    long-lived instances do not accumulate stale entries on value churn.
    )_index_key_fnNkey_fnr   
typing.Anyr   .typing.Callable[[_GV], typing.Hashable] | Noner   r   rD   c               F    t                      j        |i | ||nd | _        i | _        t                                                      D ]R\  }}| j                            |                     |          t                                                    |           Sd S )Nc                    | S r   r   )xs    r   <lambda>z&GroupedDict.__init__.<locals>.<lambda>  s     r   )rF   rG   r   r   r   r   re   r   )r   r   r   r   r   r   rH   s         r   rG   zGroupedDict.__init__  s     	$)&)))(FFkk 	 8:GGMMOO 	B 	BDAqK""4<<??CEE::>>qAAAA	B 	Br   r   r   rM   r   c                   || v rt                                          |          }|                     |          }|                     |          }||k    r$t                                          ||           d S | j                            |          }||                    |           |s| j        |= t                                          ||           | j                            |t                                	                    |           d S t                                          ||           | j                            |                     |          t                                	                    |           d S r   )
rF   r   r   rV   r   getr   r   re   r   )r   r   rM   oldold_hnew_hr   rH   s          r   rV   zGroupedDict.__setitem__
  sI   $;;''%%c**CLL%%ELL''E~~##C///[__U++F!s### +E*GGU+++K""5#%%0044S999FC'''t||E22CEE::>>sCCCCCr   c                4   t                                          |          }t                                          |           |                     |          }| j                            |          }|!|                    |           |s| j        |= d S d S d S r   )rF   r   rX   r   r   r   r   )r   r   r   r   r   rH   s        r   rX   zGroupedDict.__delitem__  s    gg!!#&&C   S!!''NN3 'K&&& ' 'r   c                   t          |          dk    r"t          ddt          |          z              || vr|r|d         S t          |          t                                          |          }|                     |          }| j                            |          }||                    |           |s| j        |= |S )Nr   z&pop expected at most 2 arguments, got r   )	rQ   r   rP   rF   rJ   r   r   r   r   )r   r   r   rM   hr   rH   s         r   rJ   zGroupedDict.pop'  s    t99q==TQT]TTUUUd?? Aw3--C  LL##NN3 #KNr   tuple[_GK, _GV]c                    t                                                      \  }}|                     |          }| j                            |          }||                    |           |s| j        |= ||fS r   )rF   rR   r   r   r   r   )r   r   rM   r   r   rH   s        r   rR   zGroupedDict.popitem7  sq    WW__&&
ULL##NN3 #KNEzr   c                z    t                                                       | j                                         d S r   )rF   rb   r   )r   rH   s    r   rb   zGroupedDict.clearA  s.    r   r   c                \    || v r!t                                          |          S || |<   |S r   )rF   r   r   s      r   r   zGroupedDict.setdefaultE  s2    $;;77&&s+++S	r   c                   t          |          dk    rt          dt          |                     |rn|d         }t          |t                    r|D ]}||         | |<   n@t	          |d          r#|                                D ]}||         | |<   n|D ]
\  }}|| |<   |                                D ]
\  }}|| |<   d S )Nr   z3update expected at most 1 positional argument, got r   r   )rQ   r   r5   _Mappingr:   r   r   )r   r   r   r   r   r   s         r   updatezGroupedDict.updateL  s	   t99q==Qc$iiQQ    	 GE%** 	  ' 'A#AhDGG'''   ' 'A#AhDGG' "    DAqDGGLLNN 	 	DAqDGG	 	r   ReverseKeysView[_GK]c                z    | j                             |                     |                    }t          |          S )a?  Return a live read-only view over all keys mapped to ``value``.

        Lookup is O(1) average time. The returned :class:`ReverseKeysView`
        reflects the current bucket contents and updates as the parent
        :class:`GroupedDict` is mutated. Returns an empty view if no key
        maps to ``value``.
        )r   r   r   r   )r   rM   r   s      r   keys_forzGroupedDict.keys_for`  s1     e!4!455v&&&r   GroupedDict[_GK, _GV]c                2    t          | | j                  }|S )Nr   )r$   r   )r   news     r   r   zGroupedDict.copyk  s    %0dl%K%K%K
r   c                *    |                                  S r   )r   r   s    r   __copy__zGroupedDict.__copy__p  s    yy{{r   iterabletyping.Iterable[_GK]GroupedDict[_GK, typing.Any]c                2     | fd|D                       S )Nc                    i | ]}|S r   r   )r   r   rM   s     r   r   z(GroupedDict.fromkeys.<locals>.<dictcomp>y  s    ///Au///r   r   )clsr  rM   s     `r   fromkeyszGroupedDict.fromkeyss  s*     s////h///000r   )r   r   r   r   r   r   r   rD   )r   r   rM   r   r   rD   )r   r   r   rD   )r   r   r   r   r   r   )r   r   rg   r   )r   r   r   r   r   r   )r   r   r   r   r   rD   )rM   r   r   r   )r   r  )r  r	  rM   r   r   r
  )r   r    r!   rh   r   rG   rV   rX   rJ   rR   rb   r   r   r  r   r  classmethodr  rj   rk   s   @r   r$   r$     s        $ &I
 BFB B B B B B B BD D D D D D&' ' ' ' ' '                         (	' 	' 	' 	'   
     !1 1 1 1 [1 1 1 1 1r   r$   )r-   r   r   r   )r1   r2   r   r3   )-
__future__r   r6   collectionsr   collections.abcr   r   enumr   r   	functoolsr   	threadingr	   TYPE_CHECKINGtyping_extensionsr
   r   __all__TypeVarr%   r&   r'   Unionr   r8   r9   r   r)   r0   r;   GenericMutableMappingr"   Setrm   r#   Hashabler   r   KeysViewr   Dictr$   r   r   r   <module>r!     s-   " " " " " "  # # # # # # / / / / / /                    	 4 +*****4 4 4 4 4 4 4 4   fnUfnUfnU
N38
OFLc*+         2   
   (\/ \/ \/ \/ \/FN384f6KCQTH6U \/ \/ \/~- - - - -VZS#X(>? - - -`e e e e eV*384 e e eP fnU&/222fnU L  L  L  L  Lfoc*  L  L  LFR1 R1 R1 R1 R1&+c3h' R1 R1 R1 R1 R1r   