
    2Bf4?                     \   d Z ddlZddlmZ ddlmZ ddlmZ ddlm	Z	 ddl
mZmZmZmZmZ dd	lmZmZmZmZ dd
lmZ ddlmZmZmZmZmZmZmZ  edd      Z edd      Z  e ddee      Z! ejD                  dd      Z# G d de	eef         Z$e$jJ                  jM                  d       y)zProvide :class:`BidictBase`.    N)
namedtuple)copy)ref   )BidirectionalMapping)ON_DUP_DEFAULTRAISEDROP_OLDDROP_NEWOnDup)DuplicationErrorKeyDuplicationErrorValueDuplicationErrorKeyAndValueDuplicationError)_iteritems_args_kw)_NONEKTVTOKTOVT	IterItemsMapOrIterItems_WriteResultzkey val oldkey oldval_DedupResultz#isdupkey isdupval invbyval fwdbykeyFBT
BidictBase)boundc                       e Zd ZdZg dZeZeZeZ	eZ
 fdZej                  dej                  eef   deddfd       Zej                  deeef   deddfd	       Zej                  deddfd
       Zdeeef   deddfdZd-dZedefd       Zed.d       ZeZdefdZdeddfdZdefdZdedefdZdedefdZ dedede!ddfdZ"dedede!dejF                  e$   fdZ%e&dedede'de(def
d       Z)dedede$de*fd Z+d!ede!deeef   deddf
d"Z,de-eef   ddfd#Z.de!deeef   deddfd$Z/de!deeef   deddfd%Z0de$d&e*ddfd'Z1d(e2de2fd)Z3e3Z4de5fd*Z6dejn                  e   fd+Z8dedefd,Z9 xZ:S )/r   z6Base class implementing :class:`BidirectionalMapping`.)_fwdm_invm_inv_invweak_hash__weakref__c           	      $   t        |   di | d| j                  v ry | j                  | j                  u r| | _        y t        | j                  dz   | j                  i | j                  | | j                  | j                  d      }|| _        y )N_inv_clsInv)r&   	_fwdm_cls	_invm_cls )	super__init_subclass____dict__r(   r)   r&   type__name__	__bases__)clskwinv_cls	__class__s      L/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/bidict/_base.pyr,   zBidictBase.__init_subclass__D   s    !'B'%==CMM)CLs||e+S]] =
ll=
	=
      _BidictBase__argr2   returnNc                      y Nr*   selfr7   r2   s      r5   __init__zBidictBase.__init__T   s    EHr6   c                      y r:   r*   r;   s      r5   r=   zBidictBase.__init__V   s    DGr6   c                      y r:   r*   )r<   r2   s     r5   r=   zBidictBase.__init__X   s    *-r6   argsc                     | j                         | _        | j                         | _        | j	                          |s|r" | j
                  d| j                  g|i | yy)zMake a new bidirectional dictionary.
        The signature behaves like that of :class:`dict`.
        Items passed in are added in the order they are passed,
        respecting the :attr:`on_dup` class attribute in the process.
        TN)r(   r   r)   r    	_init_inv_updateon_dup)r<   r@   r2   s      r5   r=   zBidictBase.__init__Z   sT     '+nn&6
 '+nn&6
2DLLt{{8T8R8 r6   c                     | j                   j                  | j                         x| _        }| j                  |_        | j                  |_        d |_        t        |       |_        d | _        y r:   )r&   __new__r!   r    r   r   r"   r<   invs     r5   rB   zBidictBase._init_invj   sT     --//>>	CJJ	JJ	 4yr6   c                     | j                   d u S r:   )r!   r<   s    r5   _isinvzBidictBase._isinvy   s    yyD  r6   c                     | j                   | j                   S | j                  J | j                         }||S | j                          | j                   S )zThe inverse of this bidict.)r!   r"   rB   rG   s     r5   inversezBidictBase.inverse}   sQ    
 99 99}}(((mmo?Jyyr6   c                     i }| j                   j                  D ]2  }t        |dd      }|D ]  }t        | |      st        | |      ||<     4 |j	                  dd       |j	                  dd       |S )zNeeded to enable pickling due to use of :attr:`__slots__` and weakrefs.

        *See also* :meth:`object.__getstate__`
        	__slots__r*   r"   Nr$   )r4   __mro__getattrhasattrpop)r<   stater1   slotsslots        r5   __getstate__zBidictBase.__getstate__   s|    
 >>)) 	6CCb1E 64&")$"5E$K6	6 			*d#		-&r6   rT   c                 n    |j                         D ]  \  }}t        | ||        | j                          y)zImplemented because use of :attr:`__slots__` would prevent unpickling otherwise.

        *See also* :meth:`object.__setstate__`
        N)itemssetattrrB   )r<   rT   rV   values       r5   __setstate__zBidictBase.__setstate__   s3    
 !;;= 	'KD%D$&	'r6   c                     | j                   j                  }| s| dS | d| j                  | j                                dS )zSee :func:`repr`.z()())r4   r/   _repr_delegaterY   )r<   clsnames     r5   __repr__zBidictBase.__repr__   sE    ..))Yb>!!D//

=>a@@r6   otherc                     t        |t        j                        rt        |       t        |      k7  ry| j                  t        fd|j                         D              S )u  *x.__eq__(other)　⟺　x == other*

        Equivalent to *dict(x.items()) == dict(other.items())*
        but more efficient.

        Note that :meth:`bidict's __eq__() <bidict.bidict.__eq__>` implementation
        is inherited by subclasses,
        in particular by the ordered bidict subclasses,
        so even with ordered bidicts,
        :ref:`== comparison is order-insensitive <eq-order-insensitive>`.

        *See also* :meth:`bidict.FrozenOrderedBidict.equals_order_sensitive`
        Fc              3   D   K   | ]  \  }} |t               |k(    y wr:   )r   ).0kvselfgets      r5   	<genexpr>z$BidictBase.__eq__.<locals>.<genexpr>   s!     Ffq!71e$)Fs    )
isinstance_tMappinglengetallrY   )r<   rc   ri   s     @r5   __eq__zBidictBase.__eq__   sE     %,D	SZ0G((FFFFr6   keyc                 V    | j                   j                  |      }| j                  |= |S r:   )r   rS   r    )r<   rr   vals      r5   _popzBidictBase._pop   s$    jjnnS!JJsO
r6   rt   rD   c                 V    | j                  |||      }|| j                  |||       y y r:   )_dedup_item_write_item)r<   rr   rt   rD   dedup_results        r5   _putzBidictBase._put   s3    ''S&9#S#|4 $r6   c                    | j                   }| j                  }|j                  |t              }|j                  |t              }|t        u}|t        u}	t	        ||	||      }
|r^|	r\| j                  ||||      ry|j                  t        u rt        ||      |j                  t        u ry|j                  t        u sJ |
S |rF|j                  t        u rt        |      |j                  t        u ry|j                  t        u sJ |
S |	rD|j                  t        u rt        |      |j                  t        u ry|j                  t        u sJ |
S )a  Check *key* and *val* for any duplication in self.

        Handle any duplication as per the passed in *on_dup*.

        (key, val) already present is construed as a no-op, not a duplication.

        If duplication is found and the corresponding :class:`~bidict.OnDupAction` is
        :attr:`~bidict.DROP_NEW`, return None.

        If duplication is found and the corresponding :class:`~bidict.OnDupAction` is
        :attr:`~bidict.RAISE`, raise the appropriate error.

        If duplication is found and the corresponding :class:`~bidict.OnDupAction` is
        :attr:`~bidict.DROP_OLD`,
        or if no duplication is found,
        return the :class:`_DedupResult` *(isdupkey, isdupval, oldkey, oldval)*.
        N)r   r    ro   r   r   _already_havekvr	   r   r   r
   rr   r   rt   r   )r<   rr   rt   rD   fwdminvmoldvaloldkeyisdupkeyisdupvalry   s              r5   rw   zBidictBase._dedup_item   sB   $ zzzzhhsE*hhsE*&&#HhG!!#sFF;yyE!1#s;;yyH$99((("  zzU")#..zzX%::)))  zzU"+C00zzX%::))) r6   r   r   c                 D    || k(  }|||k(  k(  sJ |  d| d| d|        |S )N r*   )rr   rt   r   r   isdups        r5   r|   zBidictBase._already_have
  s@     #3'IC5#axq)II'r6   ry   c                     |\  }}}}| j                   }| j                  }	|||<   ||	|<   |r|	|= |r||= t        ||||      S r:   )r   r    r   )
r<   rr   rt   ry   r   r   r   r   r~   r   s
             r5   rx   zBidictBase._write_item  sY    -9*(FFzzzzS	S	VVCff55r6   initc                     |s|sy |  xr | xr t        |d   t              }|r| j                  |d          y |xs t        |v}|r | j                  |g|i | y  | j
                  |g|i | y )Nr   )rk   r   _update_no_dup_checkr	   _update_no_rollback_update_with_rollback)r<   r   rD   r@   r2   can_skip_dup_checkcan_skip_rollbacks          r5   rC   zBidictBase._update  s    B!%X^b&^ZQI]5^%%d1g. 7E$7$D$$V9d9b9&D&&v;;;r6   c                 h    | j                   }|j                         D ]  \  }} |||t                y r:   )rx   rY   _NODUP)r<   rc   
write_itemrr   rt   s        r5   r   zBidictBase._update_no_dup_check,  s2    %%
++- 	)JS#sC(	)r6   c                 V    | j                   }t        |i |D ]  \  }} ||||        y r:   )rz   r   )r<   rD   r@   r2   putrr   rt   s          r5   r   zBidictBase._update_no_rollback1  s4    ii,d9b9 	"JS#S&!	"r6   c                 &   g }|j                   }| j                  }| j                  }t        |i |D ]'  \  }}		  |||	|      }
|
 |||	|
      } ||
|f       ) y# t        $ r* | j
                  }t        |      D ]  \  }
} ||
|         w xY w)z Update, rolling back on failure.N)appendrw   rx   r   r   _undo_writereversed)r<   rD   r@   r2   writesappend_write
dedup_itemr   rr   rt   ry   
undo_writewrite_results                r5   r   z BidictBase._update_with_rollback6  s    @B}}%%
%%
,d9b9 
	;JS#)#sF; ')#sLAlL9:
	; $ !--
2:62B ;.L,|\:;	s   
A3Br   c                     |\  }}}}|\  }}}}	|s|s| j                  |       y | j                  }
| j                  }|r|	|
|<   |||	<   |s||= |r|||<   ||
|<   |s|
|= y y y r:   )ru   r   r    )r<   ry   r   r   r   _rr   rt   r   r   r~   r   s               r5   r   zBidictBase._undo_writeH  s    #/ (Aq#/ S&&IIcNzzzzDIDLIDIDLI  r6   r<   c                     | j                   j                  | j                         }t        | j                        |_        t        | j                        |_        |j                          |S )zA shallow copy.)r4   rF   r   r   r    rB   )r<   cps     r5   r   zBidictBase.copy[  sJ     ^^##DNN3

#

#
	r6   c                 ,    t        | j                        S )zThe number of contained items.)rn   r   rJ   s    r5   __len__zBidictBase.__len__l  s    4::r6   c                 ,    t        | j                        S )z!Iterator over the contained keys.)iterr   rJ   s    r5   __iter__zBidictBase.__iter__p  s    DJJr6   c                      | j                   |   S )u#   *x.__getitem__(key)　⟺　x[key]*)r   )r<   rr   s     r5   __getitem__zBidictBase.__getitem__t  s    zz#r6   )r8   N)r8   zBidictBase[VT, KT]);r/   
__module____qualname____doc__rO   r   rD   dictr(   r)   r`   r,   rl   overloadrm   r   r   r=   r   r   rB   propertyboolrK   rM   rH   rW   r\   strrb   objectrq   ru   r   rz   Optionalr   rw   staticmethodr   r   r|   r   rx   rC   r   r   r   r   r   r   r   __copy__intr   Iteratorr   r   __classcell__)r4   s   @r5   r   r   2   s   @NI FII N  [[HbjjR0HHtH H[[GiB/GrGdG G[[-R-D- -9nRV4 9B 94 9  ! ! !    Cd  $ 4 A# AGF Gt G0 r 
5 5 5U 5t 5
3r 3 3E 3bkk,>W 3j 2 B  S T  6r 6 6, 6< 6<D <% <r2v8N <VX <]a <)*>r2v*F )4 )
"% "r2v8N "VX "]a "
;E ;.R:P ;XZ ;_c ;$ L UY &2 "  H  "++b/  r b r6   r$   )'r   typingrl   collectionsr   r   weakrefr   _abcr   _dupr   r	   r
   r   r   _excr   r   r   r   _iterr   _typingr   r   r   r   r   r   r   r   r   r   TypeVarr   r   rO   remover*   r6   r5   <module>r      s   : #  "   & B B k k % G G G .*AB.*OP	eUE5	1RZZL)D%b"f- DP
     M *r6   