wgw_dZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ejHeee e!fZ%ejLe%ee!fZ'ejPejHejRdfZ*ejVddZ,Gdd ejZeej\eZ/Gd!d"e ee!fZ0d&d#Z1e0jeGd$d%Z3y)'zProvide :class:`BidictBase`.) annotationsN)starmap)eq)MappingProxyType)BidirectionalMapping)DROP_NEW)DROP_OLD)ON_DUP_DEFAULT)RAISE)OnDup)DuplicationError)KeyAndValueDuplicationError)KeyDuplicationError)ValueDuplicationError)inverted) iteritems)KT)MISSING)OKT)OVT)VT)Maplike) MapOrItems.BTzBidictBase[t.Any, t.Any])boundceZdZdZy)BidictKeysViewzSince the keys of a bidict are the values of its inverse (and vice versa), the :class:`~collections.abc.ValuesView` result of calling *bi.values()* is also a :class:`~collections.abc.KeysView` of *bi.inverse*. N__name__ __module__ __qualname____doc__Q/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/bidict/_base.pyrr4sr%rceZdZUdZeZded<ded<eZded<eZ ded<d ed <d-fd Z e d-d Z d ed<e d-dZ e d-dZe d.dZe d/dZd0d1dZed2dZd2dZed2dZd3dZd4dZd5dZd6fd Zd7dZd8dZd8dZd9dZd:dZeifd d d! d;d"Z dd%Z$d?d&Z%d@d'Z&d@d(Z'dAd)Z(dBd*Z)dCd+Z*dDd,Z+xZ,S)E BidictBasez6Base class implementing :class:`BidirectionalMapping`.zt.MutableMapping[KT, VT]_fwdmzt.MutableMapping[VT, KT]_invmz0t.ClassVar[type[t.MutableMapping[t.Any, t.Any]]] _fwdm_cls _invm_clsz*t.ClassVar[type[BidictBase[t.Any, t.Any]]]_inv_clscBt||jyN)super__init_subclass__ _init_class)cls __class__s r&r1zBidictBase.__init_subclass__Qs !# r%cD|j|jyr/)_ensure_inv_cls _set_reversedr3s r&r2zBidictBase._init_classUs  r%zt.ClassVar[t.Any] __reversed__c|tur!|j}|tju}|rytd|j|jfD}|r t |_yd|_y)zSet __reversed__ for subclasses that do not set it explicitly according to whether backing mappings are reversible. Nc3PK|]}t|tj ywr/) issubclasst Reversible).0is r& z+BidictBase._set_reversed..fs eAq||!< es$&)r(r9allr+r,_fwdm_reversed)r3resolved overriddenbacking_reversibles r&r7zBidictBase._set_reversed\s_ j ''H!)@)@@J es}}VYVcVcFd ee-?>Tr%cht|dijdry|j|_y)aEnsure :attr:`_inv_cls` is set, computing it dynamically if necessary. All subclasses provided in :mod:`bidict` are their own inverse classes, i.e., their backing forward and inverse mappings are both the same type, but users may define subclasses where this is not the case. This method ensures that the inverse class is computed correctly regardless. See: :ref:`extending:Dynamic Inverse Class Generation` (https://bidict.rtfd.io/extending.html#dynamic-inverse-class-generation) __dict__r-N)getattrget _make_inv_clsr-r8s r&r6zBidictBase._ensure_inv_clsis., 3 B ' + +J 7 ((* r%c2j}tfd|jD}|rS|d<tjdt f|}j |_tjtjt|S)Nc3LK|]\}}t|t|k(ywr/)rIr)r?kvr3s r&rAz+BidictBase._make_inv_cls..s#Vv1WS!W5:Vs!$r-Inv) _inv_cls_dict_diffrBitemstyper GeneratedBidictInverser!r=castTyper)r3diffcls_is_own_invinv_clss` r&rKzBidictBase._make_inv_clss%%'VVV JZ#,,s+c3I-JDQ ^^vvaffRj'**r%c4|j|jdS)N)r+r,)r,r+r8s r&rQzBidictBase._inv_cls_dict_diffs  r%c |j|_|j|_|j ||dy)a8Make a new bidirectional mapping. The signature behaves like that of :class:`dict`. ktems passed via positional arg are processed first, followed by any items passed via keyword argument. Any duplication encountered along the way is handled as per :attr:`on_dup`. FrollbackN)r+r)r,r*_update)selfargkws r&__init__zBidictBase.__init__s2^^% ^^%  S"u -r%ct|dd}||St|dd}| |}||S|j}||_d|_d|_t j ||_|S)z3The inverse of this bidirectional mapping instance._invN_invweak)rI _make_inverserdreweakrefref)r_invinvweaks r&inversezBidictBase.inverses}*1vt)D ?J$ D1  )C   "/2 JN {{4(  r%cj|j}|j|_|j|_|Sr/)r-r*r))r_ris r&rfzBidictBase._make_inverses("&--/JJ JJ  r%c|jS)zAlias for :attr:`inverse`.)rkr_s r&rizBidictBase.invs||r%cx|jj}|rt|jnd}|d|dS)zSee :func:`repr`.())r4r dictrR)r_clsnamerRs r&__repr__zBidictBase.__repr__s8..))&*TZZ\"!E7!$$r%cttjtt|jj S)a;A set-like object providing a view on the contained values. Since the values of a bidict are equivalent to the keys of its inverse, this method returns a set-like object for this bidict's values rather than just a collections.abc.ValuesView. This object supports set operations like union and difference, and constant- rather than linear-time containment checks, and is no more expensive to provide than the less capable collections.abc.ValuesView would be. See :meth:`keys` for more information. )r=rUrrrkkeysrns r&valueszBidictBase.valuess'vvnR($,,*;*;*=>>r%cx|j|j}}|tur|jSt |S)aA set-like object providing a view on the contained keys. When *b._fwdm* is a :class:`dict`, *b.keys()* returns a *dict_keys* object that behaves exactly the same as *collections.abc.KeysView(b)*, except for - offering better performance - being reversible on Python 3.8+ - having a .mapping attribute in Python 3.10+ that exposes a mappingproxy to *b._fwdm*. )r)r+rsrwr)r_fwdmfwdm_clss r&rwzBidictBase.keyss2T^^h&$.tyy{HN44HHr%cx|jtur|jjSt| S)aA set-like object providing a view on the contained items. When *b._fwdm* is a :class:`dict`, *b.items()* returns a *dict_items* object that behaves exactly the same as *collections.abc.ItemsView(b)*, except for: - offering better performance - being reversible on Python 3.8+ - having a .mapping attribute in Python 3.10+ that exposes a mappingproxy to *b._fwdm*. )r+rsr)rRr0)r_r4s r&rRzBidictBase.itemss.&*^^t%;tzz!PPr%c||jvS)z;True if the mapping contains the specified key, else False.r)r_keys r& __contains__zBidictBase.__contains__ sdjj  r%ct|tjr+|jj |j k(St S)u0*x.__eq__(other)　⟺　x == other* Equivalent to *dict(x.items()) == dict(other.items())* but more efficient. Note that :meth:`bidict's __eq__() ` implementation is inherited by subclasses, in particular by the ordered bidict subclasses, so even with ordered bidicts, :ref:`== comparison is order-insensitive ` (https://bidict.rtfd.io/other-bidict-types.html#eq-is-order-insensitive). *See also* :meth:`equals_order_sensitive` ) isinstancer=Mappingr)rRNotImplementedr_others r&__eq__zBidictBase.__eq__s6 eQYY '::##%6 6r%c t|tjrt|t|k7ryt t t t|j|jS)zOrder-sensitive equality check. *See also* :ref:`eq-order-insensitive` (https://bidict.rtfd.io/other-bidict-types.html#eq-is-order-insensitive) F) rr=rlenrBrrziprRrs r&equals_order_sensitivez!BidictBase.equals_order_sensitive&sI %+s4yCJ/F72s4::<?@AAr%c|j|j}}|j|t}|j|t}|tu|tu} }|rX| rV||k(r||k(sJy|jt ur t |||jtury|jtusJ||fS|rH|jt ur t||jtury|jtusJ||fS| rD|jt ur t||jtury|jtusJ||fS)aCheck *key* and *val* for any duplication in self. Handle any duplication as per the passed in *on_dup*. If (key, val) is already present, return None since writing (key, val) would be a no-op. 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 exception. If duplication is found and the corresponding :class:`~bidict.OnDupAction` is :attr:`~bidict.DROP_OLD`, or if no duplication is found, return *(oldkey, oldval)*. N) r)r*rJrvalr rr r rrr) r_rron_duprzinvmoldvaloldkeyisdupkeyisdupvals r&_dedupzBidictBase._dedup0s;$ZZd((30((30#72F'4I( f}f}$}zzU"1#s;;zzX%::) ))"v~zzU")#..zzX%::) ))v~zzU"+C00zzX%::) ))v~r%cZ|j|j}}|j|j} }|j|j} } |||| |||tur#|tur||j | |f| |ffyy|tur=|tur5| || ||"|j |||f| ||f|||f| ||ffyy|tur(| |||j |||f| ||f| |ffyy|tusJ| |||j |||f| ||f| |ffyy)aInsert (newkey, newval), extending *unwrites* with associated inverse operations if provided. *oldkey* and *oldval* are as returned by :meth:`_dedup`. If *unwrites* is not None, it is extended with the inverse operations necessary to undo the write. This design allows :meth:`_update` to roll back a partially applied update that fails part-way through when necessary. This design also allows subclasses that require additional operations to easily extend this implementation. For example, :class:`bidict.OrderedBidictBase` calls this inherited implementation, and then extends *unwrites* with additional operations needed to keep its internal linked list nodes consistent with its items' order as changes are made. N)r)r* __setitem__ __delitem__rextend) r_newkeynewvalrrunwritesrzrfwdm_setinvm_setfwdm_delinvm_dels r&_writezBidictBase._writecsZZd!--t/?/?(!--t/?/?(  W 7!2#v&v&!$ 7 "vW'< V  V #vv.vv.vv.vv. !$7 " V #vv.vv.v&!$( (( V #vv.vv.v&!$r%Nr]rct|tjtfs#t d|j j d|s|sy| |j}|t|v}|s$|s"t|tr|j|y|rtt|tjrZt|t|zt|kDr7|j}|j||d||j|y|j}|rgnd}t!|fi|D])\}} |j#|| |} | ||| g| d|i+y#t$$r|t'|D] ^} } | |  wxYw)ziUpdate with the items from *arg* and *kw*, maybe failing and rolling back as per *on_dup* and *rollback*.'z' object is not iterableNFrr)rr=Iterabler TypeErrorr4r rr r( _init_fromSizedrcopyr^rrrrreversed) r_r`rar]rtmpwriterrr dedup_resultfnargss r&r^zBidictBase._updatesr# G45a 6 677OPQ Q2  >[[F  HB:c:#> OOC   30SXB5G#d)5S))+C KKR%K ? OOC  *2B!#,, BHC #{{3V< 'c3AAA B$ '%-h%7" TD "  s "E$E,c"|jS)z7Used for the copy protocol. See the :mod:`copy` module.)rrns r&__copy__zBidictBase.__copy__syy{r%c:|j|j|S)z%Make a (shallow) copy of this bidict.) _from_otherr4rns r&rzBidictBase.copys 55r%c|}|j||r$tjt|jS|S)aFast, private constructor based on :meth:`_init_from`. If *inv* is true, return the inverse of the instance instead of the instance itself. (Useful for pickling with dynamically-generated inverse classes -- see :meth:`__reduce__`.) )rr=rUrrk)btrriinsts r&rzBidictBase._from_others3t +.qvvb$,,'8D8r%c:|jj|jj|jj|t |t r |j nt|j}|jj|y)zDFast init from *other*, bypassing item-by-item duplication checking.N)r)clearr*updaterr(rkr)r_rris r&rzBidictBase._init_fromse   %  *%rrns r&rCrCs) djj!,, // / DJJ r%ceZdZdZy)rTzrs#""& "-%' BR !jjr2v' 66!''!%%*% &QYYt56QZZ^Q\\"%5]B%b"f-]BB  GGr%