,h |%SrSSKJr SSKrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKrSSKJr SSKJr SSKJr SSKJr SSKJr SSK J!r! \R$(a*SSK"J#r# SSK"J$r$ SSK%J&q& SSK%J'q' SSK%J(q( SS K%J)q) SS!K*J+r+ /S"Qr,\RZ"5r.\/S#4r/\"S$\S%9r0\"S&\S%9r1\"S'\S%9r2\"S(S)S%9r3\"S*S+S%9r4"S,S-\!5r5"S.S#\!5r6"S/S05r7\(aSXS2jr8O\Rr"S35r8"S4S15r:SYS5jr;SZS6jrS9r?S:r@S;rAS<rBSYS=jrCS>rDS?rESYS@jrFS[SAjrGS[SBjrH\I\J4rKS\SCjrLS\SDjrMS[SEjrN"SFSG\ \05rO"SHSI\\05rP"SJSK\ \1\245rQ\R"\S\O\I\P\T\Q05rUSL\VSM'\R"\SSNSOSPSQ.\G"54\ISRSOSPSQ.\N"54\TSSST0\H"5405rWSU\VSV'SWrX\X"\Y"55 g)]aLSupport for collections of mapped entities. The collections package supplies the machinery used to inform the ORM of collection membership changes. An instrumentation via decoration approach is used, allowing arbitrary types (including built-ins) to be used as entity collections without requiring inheritance from a base class. Instrumentation decoration relays membership change events to the :class:`.CollectionAttributeImpl` that is currently managing the collection. The decorators observe function call arguments and return values, tracking entities entering or leaving the collection. Two decorator approaches are provided. One is a bundle of generic decorators that map function arguments and return values to events:: from sqlalchemy.orm.collections import collection class MyClass: # ... @collection.adds(1) def store(self, item): self.data.append(item) @collection.removes_return() def pop(self): return self.data.pop() The second approach is a bundle of targeted decorators that wrap appropriate append and remove notifiers around the mutation methods present in the standard Python ``list``, ``set`` and ``dict`` interfaces. These could be specified in terms of generic decorator recipes, but are instead hand-tooled for increased efficiency. The targeted decorators occasionally implement adapter-like behavior, such as mapping bulk-set methods (``extend``, ``update``, ``__setslice__``, etc.) into the series of atomic mutation events that the ORM requires. The targeted decorators are used internally for automatic instrumentation of entity collection classes. Every collection class goes through a transformation process roughly like so: 1. If the class is a built-in, substitute a trivial sub-class 2. Is this class already instrumented? 3. Add in generic decorators 4. Sniff out the collection interface through duck-typing 5. Add targeted decoration to any undecorated interface method This process modifies the class at runtime, decorating methods and adding some bookkeeping properties. This isn't possible (or desirable) for built-in classes like ``list``, so trivial sub-classes are substituted to hold decoration:: class InstrumentedList(list): pass Collection classes can be specified in ``relationship(collection_class=)`` as types or a function that returns an instance. Collection classes are inspected and instrumented during the mapper compilation phase. The collection_class callable will be executed once to produce a specimen instance, and the type of that specimen will be instrumented. Functions that return built-in types like ``lists`` will be adapted to produce instrumented instances. When extending a known type like ``list``, additional decorations are not generally not needed. Odds are, the extension method will delegate to a method that's already instrumented. For example:: class QueueIsh(list): def push(self, item): self.append(item) def shift(self): return self.pop(0) There's no need to decorate these methods. ``append`` and ``pop`` are already instrumented as part of the ``list`` interface. Decorating them would fire duplicate events, which should be avoided. The targeted decoration tries not to rely on other methods in the underlying collection class, but some are unavoidable. Many depend on 'read' methods being present to properly instrument a 'write', for example, ``__setitem__`` needs ``__getitem__``. "Bulk" methods like ``update`` and ``extend`` may also reimplemented in terms of atomic appends and removes, so the ``extend`` decoration will actually perform many ``append`` operations and not call the underlying method at all. Tight control over bulk operation and the firing of events is also possible by implementing the instrumentation internally in your methods. The basic instrumentation package works under the general assumption that collection mutation will not raise unusual exceptions. If you want to closely orchestrate append and remove events with exception management, internal instrumentation may be the answer. Within your method, ``collection_adapter(self)`` will retrieve an object that you can use for explicit control over triggering append and remove events. The owning object and :class:`.CollectionAttributeImpl` are also reachable through the adapter, allowing for some very sophisticated behavior. ) annotationsN)Any)Callable)cast) Collection)Dict)Iterable)List)NoReturn)Optional)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union)NO_KEY)exc)utilNO_ARG)inspect_getfullargspec)Protocol)AttributeEventToken)CollectionAttributeImplattribute_keyed_dictcolumn_keyed_dictkeyfunc_mapping KeyFuncDict) InstanceState) collectioncollection_adapterr#r!rr%mapped_collectioncolumn_mapped_collectionattribute_mapped_collectionMappedCollection_AdaptedCollectionProtocol_T)bound_KT_VT_COLCollection[Any]_FNCallable[..., Any]c\rSrSrSSjrSrg)_CollectionConverterProtocolcgN)selfr's R/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/orm/collections.py__call__%_CollectionConverterProtocol.__call__s#r;N)r'r2returnr2)__name__ __module__ __qualname____firstlineno__r>__static_attributes__r;r@r=r7r7s5r@r7cH\rSrSr%S\S'S\S'S\S'S\S'S \S 'S rg ) r-CollectionAdapter _sa_adapterr5 _sa_appender _sa_removerzCallable[..., Iterable[Any]] _sa_iteratorr7 _sa_converterr;N)rBrCrDrE__annotations__rFr;r@r=r-r-s ""$$##..//r@c\rSrSrSr\S5r\S5r\S5r\S5r \\ R"SS5S 55r \S 5r \S 5r\S 5r\S 5rSrg)r'aBDecorators for entity collection classes. The decorators fall into two groups: annotations and interception recipes. The annotating decorators (appender, remover, iterator, converter, internally_instrumented) indicate the method's purpose and take no arguments. They are not written with parens:: @collection.appender def append(self, append): ... The recipe decorators all require parens, even those that take no arguments:: @collection.adds("entity") def insert(self, position, entity): ... @collection.removes_return() def popitem(self): ... cSUlU$)aTag the method as the collection appender. The appender method is called with one positional argument: the value to append. The method will be automatically decorated with 'adds(1)' if not already decorated:: @collection.appender def add(self, append): ... # or, equivalently @collection.appender @collection.adds(1) def add(self, append): ... # for mapping type, an 'append' may kick out a previous value # that occupies that slot. consider d['a'] = 'foo'- any previous # value in d['a'] is discarded. @collection.appender @collection.replaces(1) def add(self, entity): key = some_key_func(entity) previous = None if key in self: previous = self[key] self[key] = entity return previous If the value to append is not allowed in the collection, you may raise an exception. Something to remember is that the appender will be called for each object mapped by a database query. If the database contains rows that violate your collection semantics, you will need to get creative to fix the problem, as access via the collection will not work. If the appender method is internally instrumented, you must also receive the keyword argument '_sa_initiator' and ensure its promulgation to collection events. appender_sa_instrument_rolefns r=rScollection.appendersV", r@cSUlU$)aTag the method as the collection remover. The remover method is called with one positional argument: the value to remove. The method will be automatically decorated with :meth:`removes_return` if not already decorated:: @collection.remover def zap(self, entity): ... # or, equivalently @collection.remover @collection.removes_return() def zap(self): ... If the value to remove is not present in the collection, you may raise an exception or return None to ignore the error. If the remove method is internally instrumented, you must also receive the keyword argument '_sa_initiator' and ensure its promulgation to collection events. removerrTrVs r=rZcollection.removers2"+ r@cSUlU$)zTag the method as the collection remover. The iterator method is called with no arguments. It is expected to return an iterator over all collection members:: @collection.iterator def __iter__(self): ... iteratorrTrVs r=r]collection.iterators", r@cSUlU$)ahTag the method as instrumented. This tag will prevent any decoration from being applied to the method. Use this if you are orchestrating your own calls to :func:`.collection_adapter` in one of the basic SQLAlchemy interface methods, or to prevent an automatic ABC method decoration from wrapping your implementation:: # normally an 'extend' method on a list-like class would be # automatically intercepted and re-implemented in terms of # SQLAlchemy events and append(). your implementation will # never be called, unless: @collection.internally_instrumented def extend(self, items): ... T)_sa_instrumentedrVs r=internally_instrumented"collection.internally_instrumented,s$# r@z1.3zThe :meth:`.collection.converter` handler is deprecated and will be removed in a future release. Please refer to the :class:`.AttributeEvents.bulk_replace` listener interface in conjunction with the :func:`.event.listen` function.cSUlU$)a Tag the method as the collection converter. This optional method will be called when a collection is being replaced entirely, as in:: myobj.acollection = [newvalue1, newvalue2] The converter method will receive the object being assigned and should return an iterable of values suitable for use by the ``appender`` method. A converter must not assign values or mutate the collection, its sole job is to adapt the value the user provides into an iterable of values for the ORM's use. The default converter implementation will use duck-typing to do the conversion. A dict-like collection will be convert into an iterable of dictionary values, and other types will simply be iterated:: @collection.converter def convert(self, other): ... If the duck-typing of the object does not match the type of this collection, a TypeError is raised. Supply an implementation of this method if you want to expand the range of possible types that can be assigned in bulk or perform validation on the values about to be assigned. converterrTrVs r=rdcollection.converterAsJ"- r@c^U4SjnU$)aMark the method as adding an entity to the collection. Adds "add to collection" handling to the method. The decorator argument indicates which method argument holds the SQLAlchemy-relevant value. Arguments can be specified positionally (i.e. integer) or by name:: @collection.adds(1) def push(self, item): ... @collection.adds("entity") def do_stuff(self, thing, entity=None): ... c>ST4UlU$)Nfire_append_event_sa_instrument_beforerWargs r= decorator"collection.adds..decorator{(;S'AB $Ir@r;rlrms` r=addscollection.addsis$ r@c^U4SjnU$)aMark the method as replacing an entity in the collection. Adds "add to collection" and "remove from collection" handling to the method. The decorator argument indicates which method argument holds the SQLAlchemy-relevant value to be added, and return value, if any will be considered the value to remove. Arguments can be specified positionally (i.e. integer) or by name:: @collection.replaces(2) def __setitem__(self, index, item): ... c(>ST4UlSUlU$)Nrhfire_remove_event)rj_sa_instrument_afterrks r=rm&collection.replaces..decorators(;S'AB $&9B #Ir@r;rps` r=replacescollection.replacess   r@c^U4SjnU$)aMark the method as removing an entity in the collection. Adds "remove from collection" handling to the method. The decorator argument indicates which method argument holds the SQLAlchemy-relevant value to be removed. Arguments can be specified positionally (i.e. integer) or by name:: @collection.removes(1) def zap(self, item): ... For methods where the value to remove is not known at call-time, use collection.removes_return. c>ST4UlU$Nrurirks r=rm%collection.removes..decoratorror@r;rps` r=removescollection.removess" r@c SnU$)auMark the method as removing an entity in the collection. Adds "remove from collection" handling to the method. The return value of the method, if any, is considered the value to remove. The method arguments are not inspected:: @collection.removes_return() def pop(self): ... For methods where the value to remove is known at call-time, use collection.remove. cSUlU$r|)rvrVs r=rm,collection.removes_return..decorators&9B #Ir@r;)rms r=removes_returncollection.removes_returns  r@r;N)rBrCrDrE__doc__ staticmethodrSrZr]rar deprecatedrdrqrxr~rrFr;r@r=r'r's4++Z6  ( __  ?@.,,r@r'rIcg)z7Fetch the :class:`.CollectionAdapter` for a collection.Nr;)r's r=r(r(sr@rJc\rSrSr%SrSrS\S'S\S'S\S 'S \S 'S \S 'S\S'S\S'S.SjrS/Sjr\ S0Sj5r \ S1Sj5r Sr S2S3Sjjr SrS/SjrS4SjrS5SjrS6SjrSrS2S3SjjrS5SjrS2S7S jjrS/S!jrS"rS#rS$rS\4S%jrS\4S&jrS\4S'jrS\4S(jrS\4S)jr S\4S*jr!S+r"S,r#S-r$g)8rIiaQBridges between the ORM and arbitrary Python collections. Proxies base-level collection operations (append, remove, iterate) to the underlying Python collection, and emits add/remove events for entities entering or leaving the collection. The ORM uses :class:`.CollectionAdapter` exclusively for interaction with entity collections. )attr_key_data owner_state _converter invalidatedemptyrrstrrz)Callable[..., _AdaptedCollectionProtocol]rInstanceState[Any]rr7rboolrrcXlURUl[R"U5UlX lXlURUl SUl SUl gNF) rkeyrweakrefrefrrrJrNrrr)r<rrdatas r=__init__CollectionAdapter.__init__sN  HH [[& &,,  r@c0[R"S5 g)Nz%This collection has been invalidated.)rwarnr<s r=_warn_invalidated#CollectionAdapter._warn_invalidateds 9:r@c"UR5$)z$The entity collection being adapted.)rrs r=rCollectionAdapter.data szz|r@chURRURUR5L$)zreturn True if the owner state still refers to this collection. This will return False within a bulk replace operation, where this collection is the one being replaced. )rdictrrrs r=_referenced_by_owner&CollectionAdapter._referenced_by_owners*$$TYY/4::<??r@c6UR5R$r:rrKrs r= bulk_appenderCollectionAdapter.bulk_appenderszz|(((r@Nc>UR5RXS9 g)z8Add an entity to the collection, firing mutation events. _sa_initiatorNrr<item initiators r=append_with_event#CollectionAdapter.append_with_events !!$!@r@cUR(aS5eSUlXRRUR'g)Nz7This collection adapter is already in the 'empty' stateT)rr_empty_collectionsr)r< user_datas r= _set_emptyCollectionAdapter._set_empty#s:  E D E  9B++DII6r@cUR(dS5eSUlURRRUR5URR UR'g)Nz3This collection adapter is not in the 'empty' stateF)rrrpoprrrs r= _reset_emptyCollectionAdapter._reset_empty*sZ JJ A @ A     / / 3 3DII > dii(r@c.[R"S5e)NzZThis is a special 'empty' collection which cannot accommodate internal mutation operations)sa_excInvalidRequestErrorrs r= _refuse_emptyCollectionAdapter._refuse_empty3s(( +  r@cUR(aUR5 UR5RUSS9 gz=Add or restore an entity to the collection, firing no events.FrNrrrrKr<rs r=append_without_event&CollectionAdapter.append_without_event9s0 ::     !!$e!UR5RXS9 g)z=Remove an entity from the collection, firing mutation events.rNrrs r=remove_with_event#CollectionAdapter.remove_with_eventKs    ?r@cUR(aUR5 UR5RUSS9 g)z7Remove an entity from the collection, firing no events.FrN)rrrrLrs r=remove_without_event&CollectionAdapter.remove_without_eventQs. ::       U ;r@cUR(aUR5 UR5Rn[ U5H nU"X1S9 M g)z>Empty the collection, firing a mutation event for each entity.rNrrrrLlist)r<rrZrs r=clear_with_event"CollectionAdapter.clear_with_eventWs> ::    **,**JD D 2r@cUR(aUR5 UR5Rn[ U5H nU"USS9 M g)z'Empty the collection, firing no events.FrNr)r<rZrs r=clear_without_event%CollectionAdapter.clear_without_eventbs@ ::    **,**JD D .r@cP[UR5R55$)z(Iterate over entities in the collection.)iterrrMrs r=__iter__CollectionAdapter.__iter__ksDJJL--/00r@cb[[UR5R555$)z!Count entities in the collection.)lenrrrMrs r=__len__CollectionAdapter.__len__ps!4 113455r@cgNTr;rs r=__bool__CollectionAdapter.__bool__tsr@c0U(dgUSLaUR(aUR5 UR(aUR5 UH@nURR UR UR RUUU5 MB ggrrrrrrfire_append_wo_mutation_eventrrr<rrrrs r=#_fire_append_wo_mutation_event_bulk5CollectionAdapter._fire_append_wo_mutation_event_bulkws|  E !&&(zz!!# 77$$$$))  "r@c USLa~UR(aUR5 UR(aUR5 URR UR UR RXU5$U$)a*Notify that a entity is entering the collection but is already present. Initiator is a token owned by the InstrumentedAttribute that initiated the membership mutation, and should be left as None unless you are passing along an initiator value from a chained operation. .. versionadded:: 1.4.15 Frr<rrrs r=r/CollectionAdapter.fire_append_wo_mutation_eventsm E !&&(zz!!#99::  $"2"2"7"7# Kr@c USLa~UR(aUR5 UR(aUR5 URR UR UR RXU5$U$)zNotify that a entity has entered the collection. Initiator is a token owned by the InstrumentedAttribute that initiated the membership mutation, and should be left as None unless you are passing along an initiator value from a chained operation. F)rrrrrrhrrrs r=rh#CollectionAdapter.fire_append_eventsm E !&&(zz!!#99..  $"2"2"7"7# Kr@c0U(dgUSLaUR(aUR5 UR(aUR5 UH@nURR UR UR RUUU5 MB ggrrrrrrrurrrs r=_fire_remove_event_bulk)CollectionAdapter._fire_remove_event_bulksz  E !&&(zz!!# ++$$$$))  "r@c USLaUR(aUR5 UR(aUR5 URR UR UR RXU5 gg)zNotify that a entity has been removed from the collection. Initiator is the InstrumentedAttribute that initiated the membership mutation, and should be left as None unless you are passing along an initiator value from a chained operation. FNrrs r=ru#CollectionAdapter.fire_remove_eventsf E !&&(zz!!# II ' '  $"2"2"7"7#  "r@cUR(aUR5 URRURURR UUS9 g)zNotify that an entity is about to be removed from the collection. Only called if the entity cannot be removed after calling fire_remove_event(). )rrN)rrrfire_pre_remove_eventrr)r<rrs r=r'CollectionAdapter.fire_pre_remove_eventsN     " " $ ''       ! ! ( r@cURURURRURURUR S.$)N)rr owner_clsrrr)rrclass_rrrrs r= __getstate__CollectionAdapter.__getstate__sB99++))00II++ZZ   r@c4USUlUSUl[R"US5UlUSR UlXSlUSUl[USUR5RUl URSS5Ul g)NrrrrrrF)rrrrrrNrrJrgetattrimplrgetr)r<ds r= __setstate__CollectionAdapter.__setstate__seH ]+[[6+ F)11 $& ]+AkNDII6;; UU7E* r@)rrrrrrr)rrrrrr-)rANone)rAr-)rArr:)rrrOptional[AttributeEventToken]rAr )rAr )rrrAr )rz Iterable[Any]rAr )rr rAr )%rBrCrDrEr __slots__rOrrpropertyrrrrrrrrrrrrrrrrrrrrrhrrurrrrFr;r@r=rIrIs I "! I 54##,, K%() ,;@@)EIAA$AA AC  =0(EI@@$A@ @ <:> 36 3  3/1 6 $,=Af415&,8<(15&&/3   +r@c[U[5(de[RnU"U=(d S5nUR U=(d S5nU"U=(d S5R U5nUR U5nUR 5n U=(d SHn X;aU "XS9 MX;dMU "U SS9 M U(aURXcS9 URXS9 gg)aLoad a new collection, firing events based on prior like membership. Appends instances in ``values`` onto the ``new_adapter``. Events will be fired for any instance not present in the ``existing_adapter``. Any instances in ``existing_adapter`` not present in ``values`` will have remove events fired upon them. :param values: An iterable of collection member instances :param existing_adapter: A :class:`.CollectionAdapter` of instances to be replaced :param new_adapter: An empty :class:`.CollectionAdapter` to load with ``values`` r;rF)rN) isinstancerr IdentitySet intersection differencerrr) valuesexisting_adapter new_adapterridsetexisting_idset constants additionsremovalsrSmembers r= bulk_replacer s& fd # ## #   E+1r2N++FLb9Ifl#..y9I((3H((*H,B,   V 5  V5 1  <<  =  000O r@cU[;a [UnO[[U5n[U"55nU[;a[Un[U"55n[R 5(a<[ USS5[U5:wa [U5 [R5 U$U$![R5 f=f)aWPrepare a callable for future use as a collection class factory. Given a collection class factory (either a type or no-arg callable), return another factory that will produce compatible instances when called. This function is responsible for converting collection_class=list into the run-time behavior of collection_class=InstrumentedList. r`N) __canned_instrumentationr_CollectionFactoryTypetype__instrumentation_mutexacquirerid_instrument_classrelease)factory impl_factoryclss r=prepare_instrumentationr(6s"**/8 2G< |~ C && 04 <>"&&(( .s.5C@!#& # + + - < $ + + -s 2%B//CcURS:Xa[R"S5e[U5up[ XU5 [ XU5 [ XU5 g)z6Modify methods in a class and install instrumentation. __builtin__zGCan not instrument a built-in type. Use a subclass, even a trivial one.N)rCr ArgumentError_locate_roles_and_methods_setup_canned_roles_assert_required_roles_set_collection_attributesr'rolesmethodss r=r#r#fsT  ~~&"" ,  /s3NEG,3w/s73r@c0n0nURHn[U5R5HupE[U5(dM[ US5(a%UR nUS;deUR Xd5 SnSn[ US5(aURupU S;deX4n[ US5(aURn U S;deU nU(a Xx4-X$'MU(dMSSU4X$'M M X4$)z_search for _sa_instrument_role-decorated methods in method resolution order, assign to roles. rU)rSrZr]rdNrj)rhrurv) __mro__varsrcallablehasattrrU setdefaultrjrv) r'r1r2superclsnamemethodrolebeforeafteroparguments r=r,r,{s EMOGKK N002LDF##v45511    ,15F#'Ev677%;; GGGGv56600GGGG & 1  $dE 1 ?3 B >r@cn[R"U5nU[;aUce[UupEUR5HupgUR Xg5 M UR5HFup[ XS5n U (dMX;dM![ U S5(aM4[XU "U 55 MH gg)zsee if this class has "canned" roles based on a known collection type (dict, set, list). Apply those roles as needed to the "roles" dictionary, and also prepare "decorator" methods Nr`)rduck_type_collection __interfacesrr8rr7setattr) r'r1r2collection_type canned_roles decoratorsr<r:r;rmrWs r=r-r-s//4O,&***#/#@ &,,.JD   T (/",!1!1!3 Fd+B)$677Yr]3"4'r@c SU;d[XS5(d#[R"SUR-5eUSU;a$[[ XS5S5(dSX!S'SU;d[XS5(d#[R"SUR-5eUSU;a$[[ XS5S5(dSX!S'SU;d[XS5(d#[R"S UR-5eg ) zLensure all roles are present, and apply implicit instrumentation if needed rSz>Type %s must elect an appender method to be a collection classr`)rhrNrZzType %s must elect an iterator method to be a collection classN)r7rr+rBrr0s r=r.r.s1 gc3D&E&E"" !#&<< 0   z ' )':&');33&Dj!"WS 2B%C%C"" !#&<< 0   y  (9%&(:22%Ci !gc3D&E&E"" !#&<< 0  'Fr@c BUR5H*unupEn[UU[[X5XEU55 M, UR5Hups[USU-[X55 M SUl[ US5(dSUl[U5Ulg)zcapply ad-hoc instrumentation from decorators, class-level defaults and implicit role declarations z_sa_%sNrN) rrD_instrument_membership_mutatorrrJr7rNr"r`)r'r1r2 method_namer=r@r>r<s r=r/r/s 3:--/. .f   *)6U  3B#[[]X_gc&?@+CO 3 ( ( c7Cr@c^^^^^^T(a[[R"[T5S55n[ T[ 5(a&Tm[ U5T:=(a UT=(d SmOTU;aURT5mOSmTmAUUUUUU4SjnSUl[TS5(aTRUl TRUl TRUl U$)zERoute method args and/or return value through the collection adapter.rNc>T(abT c%T U;a[R"ST-5eUT nO:[U5T :aUT nO%T U;aUT nO[R"ST-5eURSS5nUSLaSnOUSRnT(aU(a[ UT5"WU5 T(aU(dT "U0UD6$T "U0UD6nUb[ UT5"XS5 U$)NzMissing argument %srFr)rr+rrrJr) argskwvaluerexecutorresr>r@r=r; named_argpos_args r=wrapper/_instrument_membership_mutator..wrapper s B& ..-89 t9w& ME"_yME ..-8FF?D1  HAw**H h Hf %eY 7H4&2& &$%"%C%(8Jr@TrU) rrflatten_iteratorrrintrindexr`r7rUrBr)r;r=r@r>fn_argsrUrSrTs```` @@r=rJrJs  ! !"8"@"C D  h $ $GG x/EGH4EMI7"!--1 I !!F $Gv,--&,&@&@#GnnGO Nr@cXUSLa%URnU(aURXSS9 ggg)z=Run set wo mutation events. The collection is not mutated. FNr)rJr)r'rrrQs r=__set_wo_mutationr]7s< E!))   2 2 3  "r@cVUSLa#URnU(aURXUS9nU$)zVRun set events. This event always occurs before the collection is actually mutated. Fr\)rJrhr'rrrrQs r=__setr`Es4E!)) --ds-KD Kr@cXUSLa%URnU(aURXUS9 ggg)zRun del events. This event occurs before the collection is actually mutated, *except* in the case of a pop operation, in which case it occurs afterwards. For pop operations, the __before_pop hook is called before the operation occurs. Fr\N)rJrur_s r=__delrbSs7E!))   & &t & D "r@cNURnU(aURU5 gg)z;An event which occurs on a before a pop() operation occurs.N)rJr)r'rrQs r= __before_poprdbs#%%H&&}5r@c^ Sm U 4SjnU 4SjnU 4SjnU 4SjnU 4SjnU 4SjnU 4SjnU 4S jnU 4S jn[5R5n U RS 5 U $) z:Tailored instrumentation wrappers for any list-like class.cdSUl[[UR5RUlgr)r`rrrBrrVs r=_tidy_list_decorators.._tidyl""T2;;/77 r@c*>^SU4SjjnT"U5 U$)Nc8>[XU[5nT"X5 gr:)r`r)r<rrrWs r=append0_list_decorators..append..appendqs]F;D tNr@r:r;)rWrlrgs` r=rl _list_decorators..appendps  f  r@c*>^SU4SjjnT"U5 U$)Nc8>[XU[5 T"X5 gr:rbrr<rPrrWs r=remove0_list_decorators..remove..removeys $}f 5 tOr@r:r;rWrsrgs` r=rs _list_decorators..removexs  f  r@c&>^U4SjnT"U5 U$)Nc2>[XSU5nT"XU5 gr:)r`)r<rYrPrWs r=insert0_list_decorators..insert..inserts$tU3E tE "r@r;)rWryrgs` r=ry _list_decorators..inserts # f  r@c&>^U4SjnT"U5 U$)Nc>[U[5(d+XnUb [XSU5 [XSU5nT "XU5 gUR=(d SnUR =(d SnUS:aU[ U5- nURb URnO [ U5nUS:aU[ U5- nUS:XaTX Lag[XVU5Hn[ U5U:dMX M [U5HupxURXu-U5 M g[[XVU55n [ U5[ U 5:wa%[S[ U5<S[ U 5<35e[X5HupxURXx5 M g)Nrrz#attempt to assign sequence of size z to extended slice of size )rslicerbr`stepstartrstoprange enumerateryr ValueErrorzip __setitem__) r<rYrPexistingrrrirrngrWs r=r:_list_decorators..__setitem__..__setitem__s\eU++;'$$6d474&zzQ (q19SY&E::) ::Dt9D!8CI%D19}"55t9u, $ 6$-U#3 AIt4$4uU$78C5zSX-( #5z3s85 $'s?((1$3r@r;rWrrgs` r=r%_list_decorators..__setitem__s& 2P kr@c&>^U4SjnT"U5 U$)Nc>[U[5(dXn[XSU5 T"X5 gXHn[XSU5 M T"X5 gr:)rr~rbr<rYrrWs r= __delitem__:_list_decorators..__delitem__..__delitem__sKeU++{d$.4 !KD$dE2(4r@r;rWrrgs` r=r%_list_decorators..__delitem__s  kr@c>SnT"U5 U$)NcJ[U5HnURU5 M gr:rrlr<iterablerPs r=extend0_list_decorators..extend..extendsh E"(r@r;)rWrrgs r=r _list_decorators..extends # f  r@c>SnT"U5 U$)NcL[U5HnURU5 M U$r:rrs r=__iadd__4_list_decorators..__iadd__..__iadd__s#h E"(Kr@r;)rWrrgs r=r"_list_decorators..__iadd__  hr@c*>^SU4SjjnT"U5 U$)NcH>[U5 T"X5n[XSU5 U$r:rdrbrs r=r*_list_decorators..pop..pops%  d?D $dE *Kr@r;rWrrgs` r=r_list_decorators..pops  c  r@c*>^SU4SjjnT"U5 U$)NcB>UHn[XSU5 M T"U5 gr:rbrs r=clear._list_decorators..clear..clears d$. tHr@rr;rWrrgs` r=r_list_decorators..clears  e  r@rglocalscopyr) rlrsryrrrrrrlrgs @r=_list_decoratorsrisU8*X"   AEE'N Hr@c^SmU4SjnU4SjnU4SjnU4SjnU4SjnU4SjnU4Sjn[5R5nURS 5 U$) zBTailored instrumentation wrappers for any dict-like mapping class.cdSUl[[UR5RUlgr)r`rrrBrrVs r=rg_dict_decorators.._tidyrir@c*>^SU4SjjnT"U5 U$)NcX>X;a[XUX15 [XX15nT"XU5 gr:)rbr`)r<rrPrrWs r=r:_dict_decorators..__setitem__..__setitem__s,{dI}:$}:E t% r@r:r;rs` r=r%_dict_decorators..__setitem__s ! kr@c*>^SU4SjjnT"U5 U$)Nc>>X;a[XUX!5 T"X5 gr:r)r<rrrWs r=r:_dict_decorators..__delitem__..__delitem__s{dI}: tMr@r:r;rs` r=r%_dict_decorators..__delitem__s  kr@c&>^U4SjnT"U5 U$)NcH>UHn[XUSU5 M T"U5 gr:r)r<rrWs r=r._dict_decorators..clear..clears$dItS1 tHr@r;rs` r=r_dict_decorators..clears  e  r@c4>^[4U4SjjnT"U5 U$)Nc>[U5 X;nU[La T"X5nO T"XU5nU(a [XSU5 U$r:)rdrrb)r<rdefault_to_delrrWs r=r*_dict_decorators..pop..popsC  kG& $}$W-d$,Kr@rrs` r=r_dict_decorators..pops#)  c  r@c&>^U4SjnT"U5 U$)NcN>[U5 T"U5n[XSSS5 U$)Nrrr<rrWs r=popitem2_dict_decorators..popitem..popitem)s)  d8D $Qq )Kr@r;)rWrrgs` r=r!_dict_decorators..popitem(s  gr@c">SSjnT"U5 U$)NcxX;aURX5 U$URU5nX2La [XS5 U$r:)r __getitem__r])r<rrrPs r=r88_dict_decorators..setdefault..setdefault3s?  .((-#%d48 r@r:r;)rWr8rgs r=r8$_dict_decorators..setdefault2s  jr@c,>[4SjnT"U5 U$)NcVU[Lar[US5(a8[U5H(nX0;d XXLaXX'M[XUS5 M* O)UH#up4X0;dXULaX@U'M[XS5 M% UH(nX0;d XX#LaX#X'M[XUS5 M* g)Nkeys)rr7rr])r<__otherrOrrPs r=update0_dict_decorators..update..updateBsf$7F++#G}?diw|.K(/ DI-dCL$G - '. ?diu.D(-I-d4@ '. ?dirw&> "DI%dsGT: r@rrWrrgs r=r _dict_decorators..updateAs!' ;( f  r@rgr) rrrrrr8rrrgs @r=_dict_decoratorsrsJ8  0  AEE'N Hr@c>[U[UR4-5$)zGAllow only set, frozenset and self.__class__-derived objects in binops.)r_set_binop_bases __class__r<objs r=_set_binops_check_strictras c+t~~.?? @@r@c[U[UR4-5=(d [R"U5[ :H$)z5Allow anything set-like to participate in set binops.)rrrrrBsetrs r=_set_binops_check_loosergs8 3(DNN+<<= 1  $ $S )S 0r@c^SmU4SjnU4SjnU4SjnU4SjnU4SjnU4SjnU4SjnU4S jnU4S jnU4S jn U4S jn U4S jn U4Sjn [5R5n U RS5 U $)z9Tailored instrumentation wrappers for any set-like class.cdSUl[[UR5RUlgr)r`rrrBrrVs r=rg_set_decorators.._tidyrs""S"++.66 r@c*>^SU4SjjnT"U5 U$)Nc\>X;a[XU[5nO [XU5 T"X5 gr:)r`rr]rrs r=add)_set_decorators..add..addws( d=&A!$}= tOr@r:r;)rWrrgs` r=r_set_decorators..addvs  c  r@c*>^SU4SjjnT"U5 U$)NcB>X;a[XU[5 T"X5 gr:rqrrs r=discard1_set_decorators..discard..discard}d=&9 tOr@r:r;)rWrrgs` r=r _set_decorators..discards  gr@c*>^SU4SjjnT"U5 U$)NcB>X;a[XU[5 T"X5 gr:rqrrs r=rs/_set_decorators..remove..removerr@r:r;rus` r=rs_set_decorators..removes  f  r@c&>^U4SjnT"U5 U$)NcP>[U5 T"U5n[XS[5 U$r:)rdrbrrs r=r)_set_decorators..pop..pops'  d8D $dF +Kr@r;rs` r=r_set_decorators..pops  c  r@c>SnT"U5 U$)NcJ[U5HnURU5 M gr:)rrsrs r=r-_set_decorators..clear..clearsT  D!#r@r;rs r=r_set_decorators..clears " e  r@c>SnT"U5 U$)Nc8UHnURU5 M gr:)rr<rPrs r=r/_set_decorators..update..updatesr@r;rs r=r_set_decorators..updates  f  r@c>SnT"U5 U$)Ncf[X5(d[$UHnURU5 M U$r:)rNotImplementedrrs r=__ior__1_set_decorators..__ior__..__ior__s-+D88%%Kr@r;)rWr rgs r=r  _set_decorators..__ior__s  gr@c>SnT"U5 U$)Nc8UHnURU5 M gr:)rrs r=difference_updateE_set_decorators..difference_update..difference_updates T"r@r;)rWrrgs r=r*_set_decorators..difference_updates #    r@c>SnT"U5 U$)Ncf[X5(d[$UHnURU5 M U$r:)rr rrs r=__isub__3_set_decorators..__isub__..__isub__s.+D88%% T"Kr@r;)rWrrgs r=r!_set_decorators..__isub__rr@c>SnT"U5 U$)NcURU5[U5p2X2- X#- pTUHnURU5 M UHnURU5 M gr:)rrrsrr<otherwanthaversrrs r=intersection_updateI_set_decorators..intersection_update..intersection_updatesN**513t9$+t{C D!r@r;)rWrrgs r=r,_set_decorators..intersection_updates  !"""r@c>SnT"U5 U$)Nc[X5(d[$URU5[U5p2X2- X#- pTUHnUR U5 M UHnUR U5 M U$r:)rr rrrsrrs r=__iand__3_set_decorators..__iand__..__iand__sd+D88%%**513t9$+t{C D!Kr@r;)rWr"rgs r=r"!_set_decorators..__iand__  hr@c>SnT"U5 U$)NcURU5[U5p2X2- X#- pTUHnURU5 M UHnURU5 M gr:)symmetric_differencerrsrrs r=symmetric_difference_updateY_set_decorators..symmetric_difference_update..symmetric_difference_updatesN22593t9$+t{C D!r@r;)rWr)rgs r=r)4_set_decorators..symmetric_difference_updates  )***r@c>SnT"U5 U$)Nc[X5(d[$URU5[U5p2X2- X#- pTUHnUR U5 M UHnUR U5 M U$r:)rr r(rrsrrs r=__ixor__3_set_decorators..__ixor__..__ixor__sd+D88%%22593t9$+t{C D!Kr@r;)rWr.rgs r=r.!_set_decorators..__ixor__r%r@rgr)rrrsrrrr rrrr"r)r.rrgs @r=_set_decoratorsr1osh7     !  # +  AEE'N Hr@c\rSrSrSrSrg)InstrumentedListiz-An instrumented version of the built-in list.r;NrBrCrDrErrFr;r@r=r3r37r@r3c\rSrSrSrSrg)InstrumentedSetiz,An instrumented version of the built-in set.r;Nr4r;r@r=r7r7s6r@r7c\rSrSrSrSrg)InstrumentedDictiz-An instrumented version of the built-in dict.r;Nr4r;r@r=r9r9r5r@r9z/util.immutabledict[Any, _CollectionFactoryType]rrlrsr)rSrZr]rr]rzMutil.immutabledict[Any, Tuple[Dict[str, str], Dict[str, Callable[..., Any]]]]rCcSSKJq SSKJq SSKJq SSKJq SSKJq SSKJq SSKJq SS KJq [[5 [[5 [[5 g) Nrr"r rr$)r))r*)r+)r,) r)r#r!rr%r*r+r,r#r3r7)lclss r=__gor<As7 347.4;>3&'o&k"r@)r'r3rArIr:)r%z4Union[Type[Collection[Any]], _CollectionFactoryType]rAr)rAzDict[str, Callable[[_FN], _FN]])r<rrrrAr)Zr __future__roperator threadingtypingrrrrrr r r r r rrrrrrbaserrrrsql.baser util.compatr util.typingr attributesrrr)rr!r#r%stater&__all__Lockr rr.r0r1r2r4r7r-r'r( attrgetterrIrr(r#r,r-r.r/rJr]r`rbrdrrr frozensetrrrr1r3r7r9 immutabledictrrrrOrCr<rr;r@r=rMsbF#  0" /3742.$ $..*""&B"BC T e3 e3v./ e/068600JJZF",,];z+z+z 'PT- A--`4**Z42 @#0;|   E6J Ze P#A _ D8tBx87c"g78tCH~8   "  " I   $#&      8 L   H%'7'9:  4#4VXr@