߷iw_dZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ej$eee e!fZ%ej&e%ee!fZ'ej(ej$ej)dfZ*ej+ddZ,Gdd ej-eej.eZ/Gd!d"e ee!fZ0d*d'Z1e02Gd(d)Z3dS)+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])boundceZdZdZdS)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/mmwave/public_html/mmwave/venv/lib/python3.11/site-packages/bidict/_base.pyrr4sr%rceZdZUdZeZded<ded<eZded<eZ ded<d ed <d[fd Z e d[dZ ded<e d[dZ e d[dZe d\dZe d]dZd^d_dZed`dZd`d Zed`d!Zdad#Zdbd%Zdcd'Zddfd) Zded-Zdfd0Zdfd1Zdgd7Zdhd@ZeifdAdAdBdidGZ djdJZ!djdKZ"e#dkdldOZ$dmdPZ%dndRZ&dndSZ'dodUZ(dpdWZ)dqdXZ*drdZZ+xZ,S)s 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_clsreturnNonecpt|dSN)super__init_subclass__ _init_class)cls __class__s r&r3zBidictBase.__init_subclass__Qs/ !!### r%cV||dSr1)_ensure_inv_cls _set_reversedr5s r&r4zBidictBase._init_classUs,  r%zt.ClassVar[t.Any] __reversed__c|tur|j}|tju}|rdStd|j|jfD}|rt nd|_dS)zSet __reversed__ for subclasses that do not set it explicitly according to whether backing mappings are reversible. Nc3JK|]}t|tjVdSr1) issubclasst Reversible).0is r& z+BidictBase._set_reversed..fs. e eAq|!>Tr%ct|didrdS||_dS)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-r:s r&r8zBidictBase._ensure_inv_clsisB, 3 B ' ' + +J 7 7  F((** r%r5type[BT]cD}tfd|D}|rS|d<tjdt f|}j|_tjtj t|S)Nc3RK|]!\}}t|t|kV"dSr1)rKr)rAkvr5s r&rCz+BidictBase._make_inv_cls..s8VVv1WS!W55:VVVVVVr%r-Inv) _inv_cls_dict_diffrDitemstyper GeneratedBidictInverser!r?castTyper)r5diffcls_is_own_invinv_clss` r&rMzBidictBase._make_inv_clss%%''VVVVVVVVV  JZ#,+++c3I-JDQQ ^vafRj'***r%dict[str, t.Any]c |j|jdS)N)r+r,)r,r+r:s r&rTzBidictBase._inv_cls_dict_diffs   r%r$argMapOrItems[KT, VT]kwrc ||_||_|||ddS)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)selfr_ras r&__init__zBidictBase.__init__sD^^%% ^^%%  S"u -----r%BidictBase[VT, KT]ct|dd}||St|dd}||}||S|}||_d|_d|_t j||_|S)z3The inverse of this bidirectional mapping instance._invN_invweak)rK _make_inverserjrkweakrefref)rfinvinvweaks r&inversezBidictBase.inverses*1vt)D)D ?J$ D11  '))C   ""/2 JN {4((  r%c^|}|j|_|j|_|Sr1)r-r*r))rfros r&rlzBidictBase._make_inverses&"&--//J J  r%c|jS)zAlias for :attr:`inverse`.)rqrfs r&rozBidictBase.invs |r%strct|jj}|r!t|nd}|d|dS)zSee :func:`repr`.())r6r dictrU)rfclsnamerUs r&__repr__zBidictBase.__repr__sB.)&*2TZZ\\"""$$E$$$$r%BidictKeysView[VT]cztjtt|jS)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?rXrrrqkeysrts r&valueszBidictBase.valuess)vnR($,*;*;*=*=>>>r%t.KeysView[KT]cv|j|j}}|tur|nt |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+rzrr)rffwdmfwdm_clss r&rzBidictBase.keyss5T^h&$..tyy{{{N44H4HHr%t.ItemsView[KT, VT]c|jtur|jnt 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+rzr)rUr2)rfr6s r&rUzBidictBase.itemss6&*^t%;%;tz!!!Pr%keyt.Anyboolc||jvS)z;True if the mapping contains the specified key, else False.r)rfrs r& __contains__zBidictBase.__contains__ sdj  r%otherobjectct|tjr/|j|kSt 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)rUNotImplementedrfrs r&__eq__zBidictBase.__eq__s? eQY ' ' 7:##%%6 6r%c "t|tjr t|t|krdSt t t t||S)zOrder-sensitive equality check. *See also* :ref:`eq-order-insensitive` (https://bidict.rtfd.io/other-bidict-types.html#eq-is-order-insensitive) F) rr?rlenrDrrziprUrs r&equals_order_sensitivez!BidictBase.equals_order_sensitive&se %++ s4yyCJJ/F/F572s4::<<??@@AAAr%rvalon_dupr DedupResult[KT, VT]cZ|j|j}}||t}||t}|tu|tu} }|rQ| rO||kr ||ksJdS|jt urt |||jturdS|jtusJn|r>|j t urt||j turdS|j tusJn?| r=|jt urt||jturdS|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*rLrrr rr r rrr) rfrrrrinvmoldvaloldkeyisdupkeyisdupvals r&_dedupzBidictBase._dedup0sX$Zd((300((300#72F'4I(  * *f}}f}}}}tzU""1#s;;;zX%%t:)))))  *zU"")#...zX%%t:)))))  *zU""+C000zX%%t:))))v~r%newkeynewvalrOKT[KT]rOVT[VT]unwritesUnwrites | Nonec~|j|j}}|j|j} }|j|j} } |||| |||tur*|tur!||| |f| |ffdSdS|turJ|turA| || ||'||||f| ||f|||f| ||ffdSdS|tur1| ||"||||f| ||f| |ffdSdS|tusJ| ||"||||f| ||f| |ffdSdS)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) rfrrrrrrrfwdm_setinvm_setfwdm_delinvm_dels r&_writezBidictBase._writecsZd!-t/?(!-t/?(      W  7!2!2#v&v&!$# 7 " "vW'<'< HV    HV   #vv.vv.vv.vv. !$#7 " " HV   #vv.vv.v&!$#(((( HV   #vv.vv.v&!$#r%Nrdrt.Mapping[str, VT]rd bool | None OnDup | Nonect|tjtfst d|jjd|s|sdS||j}| t|v}|s.|s,t|tr| |dS|rt|tj rtt|t|zt|krD| }|||d|| |dS|j}|rgnd}t!|fi|D]W\}} ||| |} n*#t$$r|t'|D] ^} } | |  wxYw| ||| g| Rd|iXdS)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 TypeErrorr6r rr r( _init_fromSizedrcopyrerrrrreversed) rfr_rardrtmpwriterrr dedup_resultfnargss r&rezBidictBase._updates# G455 RP 6PPPQQ Q 2  F >[F  H B :c:#>#>  OOC F   300 SXXB5G#d))5S5S))++C KKR%K ? ? ? OOC F *2$rs#"""""""""""""&&&&&& """"""------%%%%%%'''''' BR !jr2v' 6!'!%*% &QYt5666QZ^Q\"%5]B]B]B]B]B%b"f-]B]B]BB     GGGGGGGGGGr%