1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
U
¸ý°dWRã@sŠdZddlmZddlZddlmZddlZddlmZddl    Z    ddl    m
Z
ddl    m Z ddl    m Z dd    l    m Z dd
l    mZdd l    mZdd l    mZdd l    mZddl    mZddl    mZddl    mZddl    mZddl    mZddl    mZddl    mZddl    mZddl    mZddlZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#dd l$m%Z%dd!l&m'Z'ed"e
d#Z(e    j)r¸dd$l*m+Z+dd%l*m,Z,dd&l*m-Z-Gd'd(„d(e#j.eeƒZ/Gd)d*„d*e e(ƒZ0ee e(e0e(fZ1Gd+d,„d,e/eƒZ2Gd-d.„d.e/ee e!ƒZ3Gd/d0„d0e3eƒZ4Gd1d2„d2e'ƒZ5Gd3d4„d4e3eƒZ6Gd5d6„d6e6eƒZ7Gd7d8„d8e6eƒZ8dS)9a•Attribute implementation for _Dispatch classes.
 
The various listener targets for a particular event class are represented
as attributes, which refer to collections of listeners to be fired off.
These collections can exist at the class level as well as at the instance
level.  An event is fired off using code like this::
 
    some_object.dispatch.first_connect(arg1, arg2)
 
Above, ``some_object.dispatch`` would be an instance of ``_Dispatch`` and
``first_connect`` is typically an instance of ``_ListenerCollection``
if event listeners are present, or ``_EmptyListener`` if none are present.
 
The attribute mechanics here spend effort trying to ensure listener functions
are available with a minimum of function call overhead, that unnecessary
objects aren't created (i.e. many empty per-instance listener collections),
as well as that everything is garbage collectable when owning references are
lost.  Other features such as "propagation" of listener functions across
many ``_Dispatch`` instances, "joining" of multiple ``_Dispatch`` instances,
as well as support for subclass propagation (e.g. events assigned to
``Pool`` vs. ``QueuePool``) are all implemented here.
 
é)Ú annotationsN)Úchain)Ú TracebackType)ÚAny)Úcast)Ú
Collection)ÚDeque)Ú    FrozenSet)ÚGeneric)ÚIterator)ÚMutableMapping)ÚMutableSequence)ÚNoReturn)ÚOptional)ÚSequence)ÚSet)ÚTuple)ÚType)ÚTypeVar)ÚUnioné)Úlegacy)Úregistry)Ú_ET)Ú    _EventKey)Ú_ListenerFnTypeé)Úexc)Úutil)ÚAsyncAdaptedLock)ÚProtocolÚ_T)Úbound)Ú    _Dispatch)Ú_DispatchCommon)Ú_HasEventsDispatchc@s(eZdZUdZded<ddœdd„ZdS)Ú RefCollection)Úrefzweakref.ref[RefCollection[_ET]]r'©ÚreturncCst |tj¡S©N)Úweakrefr'rZ_collection_gced©Úself©r.úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/event/attr.pyÚ_memoized_attr_refPsz RefCollection._memoized_attr_refN)Ú__name__Ú
__module__Ú __qualname__Ú    __slots__Ú__annotations__r0r.r.r.r/r&Ks
r&c@s†eZdZdddœdd„Zdddœdd„Zddd    œd
d „Zdddœd d „Zdddœdd„Zddœdd„Zddœdd„Z    ddœdd„Z
dS)Ú_empty_collectionr!ÚNone)Úelementr)cCsdSr*r.©r-r8r.r.r/ÚappendUsz_empty_collection.appendcCsdSr*r.r9r.r.r/Ú
appendleftXsz_empty_collection.appendleftz Sequence[_T])Úotherr)cCsdSr*r.)r-r<r.r.r/Úextend[sz_empty_collection.extendcCsdSr*r.r9r.r.r/Úremove^sz_empty_collection.removerÚboolcCsdS©NFr.r9r.r.r/Ú __contains__asz_empty_collection.__contains__z Iterator[_T]r(cCstgƒSr*)Úiterr,r.r.r/Ú__iter__dsz_empty_collection.__iter__cCsdSr*r.r,r.r.r/Úcleargsz_empty_collection.clearÚintcCsdS©Nrr.r,r.r.r/Ú__len__jsz_empty_collection.__len__N) r1r2r3r:r;r=r>rArCrDrGr.r.r.r/r6Tsr6c@sìeZdZUdZdZded<ded<ded<ded    <d
ed <d ed <dddœdd„Zddddœdd„Zdddœdd„Zddddœdd„Z    ddddœdd „Z
ddddœd!d"„Z d#dd$œd%d&„Z ddd'œd(d)„Z dd*œd+d,„Zd-d.d/œd0d1„Zd2S)3Ú_ClsLevelDispatchz2Class-level events on :class:`._Dispatch` classes.)ÚclsnameÚnameÚ    arg_namesÚhas_kwÚlegacy_signaturesÚ    _clslevelÚ __weakref__ÚstrrIrJz Sequence[str]rKr?rLz,MutableSequence[legacy._LegacySignatureType]rMzCMutableMapping[Type[_ET], _ListenerFnSequenceType[_ListenerFnType]]rNzType[_HasEventsDispatch[_ET]]r)Úparent_dispatch_clsÚfncCsv|j|_|j|_t |¡}|jdd…|_t|jƒ|_    t
t t t |dgƒdd„dƒƒ|_t |||¡|_t ¡|_dS)NrZ_legacy_signaturescSs|dSrFr.)Úsr.r.r/Ú<lambda>”óz,_ClsLevelDispatch.__init__.<locals>.<lambda>)Úkey)r1rJrIrZinspect_getfullargspecÚargsrKr?ÚvarkwrLÚlistÚreversedÚsortedÚgetattrrMrZ_augment_fn_docsÚ__doc__r+ÚWeakKeyDictionaryrN)r-rQrRÚargspecr.r.r/Ú__init__‡s
 
ÿÿÿz_ClsLevelDispatch.__init__©rRÚnamedr)cCsN|r| |¡}|jrJztj|dd}Wntk
r:YnXt |||¡}|S)NT)Zno_self)Ú_wrap_fn_for_kwrMrZget_callable_argspecÚ    TypeErrorrZ_wrap_fn_for_legacy)r-rRrbr_r.r.r/Ú_adjust_fn_specœs
z!_ClsLevelDispatch._adjust_fn_spec)rRr)csddddœ‡‡fdd„ }|S)Nr©rWÚkwr)cs$ttˆj|ƒƒ}| |¡ˆf|ŽSr*)ÚdictÚziprKÚupdate)rWrgZargdict©rRr-r.r/Úwrap_kw«s
z2_ClsLevelDispatch._wrap_fn_for_kw.<locals>.wrap_kwr.)r-rRrlr.rkr/rcªsz!_ClsLevelDispatch._wrap_fn_for_kwú_EventKey[_ET]r7)Ú    event_keyÚ    is_appendr)cCs²|j}t|tƒstdƒ‚t|ddƒs6t d|›d¡‚t |¡D]`}||k    rb||j    krb| 
|¡q@||j    krv| 
|¡|rŽ|j    |  |j ¡q@|j    |  |j ¡q@t ||¡dS)Nz*Class-level Event targets must be classes.Ú_sa_propagate_class_eventsTz&Can't assign an event directly to the z class)Údispatch_targetÚ
isinstanceÚtypeÚAssertionErrorr\rZInvalidRequestErrorrÚwalk_subclassesrNÚupdate_subclassr:Ú
_listen_fnr;rZ_stored_in_collection)r-rnroÚtargetÚclsr.r.r/Ú_do_insert_or_append²s(ÿþ 
ÿ 
 
z&_ClsLevelDispatch._do_insert_or_append©rnÚ    propagater)cCs|j|dddS)NF©ro©rz©r-rnr|r.r.r/ÚinsertÌsz_ClsLevelDispatch.insertcCs|j|dddS)NTr}r~rr.r.r/r:Ïsz_ClsLevelDispatch.appendú    Type[_ET])rxr)cs|||jkr2t|ddƒr&t ¡|j|<n tƒ|j|<|j|‰|jdd…D],}||jkrJˆ ‡fdd„|j|Dƒ¡qJdS)NrpTrcsg|]}|ˆkr|‘qSr.r.)Ú.0rR©Zclslevelr.r/Ú
<listcomp>Þsz5_ClsLevelDispatch.update_subclass.<locals>.<listcomp>)rNr\Ú collectionsÚdequer6Ú__mro__r=)r-rxryr.rƒr/rvÒs
 
 
ÿz!_ClsLevelDispatch.update_subclass©rnr)cCsB|j}t |¡D] }||jkr|j| |j¡qt ||¡dSr*)rqrrurNr>rwrÚ_removed_from_collection)r-rnrxryr.r.r/r>ás
 
z_ClsLevelDispatch.remover(cCs8tƒ}|j ¡D]}| |¡| ¡qt ||¡dS)zClear all class level listenersN)ÚsetrNÚvaluesrjrDrÚ_clear)r-Zto_clearÚ
dispatcherr.r.r/rDés
 
 
z_ClsLevelDispatch.clearú_Dispatch[_ET]ú_ClsLevelDispatch[_ET]©Úobjr)cCs|S©z™Return an event collection which can be modified.
 
        For _ClsLevelDispatch at the class level of
        a dispatcher, this returns self.
 
        r.©r-r‘r.r.r/Ú
for_modifyòsz_ClsLevelDispatch.for_modifyN)r1r2r3r]r4r5r`rercrzr€r:rvr>rDr”r.r.r.r/rHqs$
 
    rHc@sòeZdZUdZded<ddddœdd„Zd    dd
œd d „Zd dœdd„Zddœdd„Zddœdd„Z    d    d    ddœdd„Z
d    d    ddœdd„Z d    d    ddœdd„Z d    d    ddœdd„Z d ddd!œd"d#„Zd ddd!œd$d%„Zd dd&œd'd(„Zd)d*d+œd,d-„Zd.S)/Ú_InstanceLevelDispatchr.rÚparentrr?racCs|j ||¡Sr*)r–re©r-rRrbr.r.r/resz&_InstanceLevelDispatch._adjust_fn_specr©Úitemr)cCs
tƒ‚dSr*©ÚNotImplementedError©r-r™r.r.r/rAsz#_InstanceLevelDispatch.__contains__rEr(cCs
tƒ‚dSr*ršr,r.r.r/rG    sz_InstanceLevelDispatch.__len__úIterator[_ListenerFnType]cCs
tƒ‚dSr*ršr,r.r.r/rC sz_InstanceLevelDispatch.__iter__cCs
tƒ‚dSr*ršr,r.r.r/Ú__bool__sz_InstanceLevelDispatch.__bool__r7rfcOs
tƒ‚dSr*rš©r-rWrgr.r.r/Ú    exec_oncesz _InstanceLevelDispatch.exec_oncecOs
tƒ‚dSr*ršrŸr.r.r/Úexec_once_unless_exceptionsz1_InstanceLevelDispatch.exec_once_unless_exceptioncOs
tƒ‚dSr*ršrŸr.r.r/Ú_exec_w_sync_on_first_runsz0_InstanceLevelDispatch._exec_w_sync_on_first_runcOs
tƒ‚dSr*ršrŸr.r.r/Ú__call__sz_InstanceLevelDispatch.__call__rmr{cCs
tƒ‚dSr*ršrr.r.r/r€sz_InstanceLevelDispatch.insertcCs
tƒ‚dSr*ršrr.r.r/r:!sz_InstanceLevelDispatch.appendrˆcCs
tƒ‚dSr*rš©r-rnr.r.r/r>$sz_InstanceLevelDispatch.removeú_DispatchCommon[_ET]ú_InstanceLevelDispatch[_ET]rcCs|Sr’r.r“r.r.r/r”'s    z!_InstanceLevelDispatch.for_modifyN)r1r2r3r4r5rerArGrCržr r¡r¢r£r€r:r>r”r.r.r.r/r•üs
r•c@s2eZdZUdZdZeƒZded<dZded<ded    <d
ed <d ed <dddœdd„Z    dddœdd„Z
ddddœdd„Z ddddœdd„Z ddddœdd„Z ddddœd d!„Zddddœd"d#„Zddddœd$d%„Zddddœd&d'„Zddd(dœd)d*„Zdd+d,œd-d.„Zd/d0œd1d2„Zd3d0œd4d5„Zd+d0œd6d7„Zd8S)9Ú_EmptyListenerzÙServes as a proxy interface to the events
    served by a _ClsLevelDispatch, when there are no
    instance-level events present.
 
    Is replaced by _ListenerCollection when instance-level
    events are added.
 
    )r–Úparent_listenersrJzFrozenSet[_ListenerFnType]r|r.z    Tuple[()]Ú    listenersrr–z(_ListenerFnSequenceType[_ListenerFnType]r¨rPrJr©r–Ú
target_clscCs2||jkr| |¡||_|j||_|j|_dSr*)rNrvr–r¨rJ©r-r–r«r.r.r/r`Es
 
 
 z_EmptyListener.__init__r¥ú_ListenerCollection[_ET]rcCs`td|ƒ}|jdk    st‚t|j|jƒ}t||jƒ|krFt||j|ƒntt||jƒt    ƒs\t‚|S)zìReturn an event collection which can be modified.
 
        For _EmptyListener at the instance level of
        a dispatcher, this generates a new
        _ListenerCollection, applies it to the instance,
        and returns it.
 
        rŽN)
rZ _instance_clsrtÚ_ListenerCollectionr–r\rJÚsetattrrrÚ_JoinedListener)r-r‘Úresultr.r.r/r”Ls
z_EmptyListener.for_modifyrrrfcOs tdƒ‚dS)Nzneed to call for_modify()ršrŸr.r.r/Ú _needs_modifyasz_EmptyListener._needs_modifycOs|j||ŽdSr*©r²rŸr.r.r/r dsz_EmptyListener.exec_oncecOs|j||ŽdSr*r³rŸr.r.r/r¡gsz)_EmptyListener.exec_once_unless_exceptioncOs|j||ŽdSr*r³rŸr.r.r/r€jsz_EmptyListener.insertcOs|j||ŽdSr*r³rŸr.r.r/r:msz_EmptyListener.appendcOs|j||ŽdSr*r³rŸr.r.r/r>psz_EmptyListener.removecOs|j||ŽdSr*r³rŸr.r.r/rDssz_EmptyListener.clearr7cOs|jD]}|||ŽqdS©zExecute this event.N©r¨©r-rWrgrRr.r.r/r£vs
z_EmptyListener.__call__r?r˜cCs
||jkSr*rµrœr.r.r/rA|sz_EmptyListener.__contains__rEr(cCs
t|jƒSr*)Úlenr¨r,r.r.r/rGsz_EmptyListener.__len__rcCs
t|jƒSr*)rBr¨r,r.r.r/rC‚sz_EmptyListener.__iter__cCs
t|jƒSr*)r?r¨r,r.r.r/rž…sz_EmptyListener.__bool__N)r1r2r3r]r4Ú    frozensetr|r5r©r`r”r²r r¡r€r:r>rDr£rArGrCržr.r.r.r/r§3s*
     r§c@s.eZdZddœdd„Zddddd    œd
d „Zd S) Ú_MutexProtocolr?r(cCsdSr*r.r,r.r.r/Ú    __enter__Šsz_MutexProtocol.__enter__zOptional[Type[BaseException]]zOptional[BaseException]zOptional[TracebackType]zOptional[bool])Úexc_typeÚexc_valÚexc_tbr)cCsdSr*r.)r-r»r¼r½r.r.r/Ú__exit__sz_MutexProtocol.__exit__N)r1r2r3rºr¾r.r.r.r/r¹‰sr¹c@sìeZdZUdZded<ded<ded<ded<ded    <d
d œd d „Zdd œdd„Zdddd
dœdd„Zddd
dœdd„Zddd
dœdd„Z    ddd
dœdd„Z
ddd
dœdd„Z dddœdd„Z d d œd!d"„Z d#d œd$d%„Zdd œd&d'„Zd(S))Ú_CompoundListener)Ú_exec_once_mutexÚ
_exec_onceÚ_exec_w_sync_oncer¹rÀúCollection[_ListenerFnType]r¨r©r?rÁrÂr7r(cCs tƒ|_dSr*)rrÀr,r.r.r/Ú _set_asyncioŸsz_CompoundListener._set_asynciocCst ¡Sr*)Ú    threadingÚLockr,r.r.r/Ú_memoized_attr__exec_once_mutex¢sz1_CompoundListener._memoized_attr__exec_once_mutexr)Úretry_on_exceptionrWrgr)c    OsX|jH|jsJz*z|||Žd}Wnd}‚YnXW5|rB|sHd|_XW5QRXdS)NTF)rÀrÁ)r-rÈrWrgÚ    exceptionr.r.r/Ú_exec_once_impl¥s
 z!_CompoundListener._exec_once_implrfcOs|js|jd|ž|ŽdS)z]Execute this event, but only if it has not been
        executed already for this collection.FN)F©rÁrÊrŸr.r.r/r ´sz_CompoundListener.exec_oncecOs|js|jd|ž|ŽdS)atExecute this event, but only if it has not been
        executed already for this collection, or was called
        by a previous exec_once_unless_exception call and
        raised an exception.
 
        If exec_once was already called, then this method will never run
        the callable regardless of whether it raised or not.
 
        .. versionadded:: 1.3.8
 
        TN)TrËrŸr.r.r/r¡»s z,_CompoundListener.exec_once_unless_exceptionc    OsL|js>|j*z|||ŽWn‚YnXd|_W5QRXn
|||ŽdS)anExecute this event, and use a mutex if it has not been
        executed already for this collection, or was called
        by a previous _exec_w_sync_on_first_run call and
        raised an exception.
 
        If _exec_w_sync_on_first_run was already called and didn't raise an
        exception, then a mutex is not used.
 
        .. versionadded:: 1.4.11
 
        TN)rÂrÀrŸr.r.r/r¢Ês z+_CompoundListener._exec_w_sync_on_first_runcOs0|jD]}|||Žq|jD]}|||ŽqdSr´©r¨r©r¶r.r.r/r£ás
 
z_CompoundListener.__call__r˜cCs||jkp||jkSr*rÌrœr.r.r/rAész_CompoundListener.__contains__rEcCst|jƒt|jƒSr*)r·r¨r©r,r.r.r/rGìsz_CompoundListener.__len__rcCst|j|jƒSr*)rr¨r©r,r.r.r/rCïsz_CompoundListener.__iter__cCst|jp |jƒSr*)r?r©r¨r,r.r.r/ržòsz_CompoundListener.__bool__N)r1r2r3r4r5rÄrÇrÊr r¡r¢r£rArGrCržr.r.r.r/r¿–s"
r¿c@s´eZdZUdZdZded<ded<ded<d    ed
<d ed <dd dœdd„Zdddœdd„Zd)ddddœdd„Zddddœdd„Z    ddddœd d!„Z
ddd"œd#d$„Z dd%œd&d'„Z d(S)*r®zÛInstance-level attributes on instances of :class:`._Dispatch`.
 
    Represents a collection of listeners.
 
    As of 0.7.9, _ListenerCollection is only first
    created via the _EmptyListener.for_modify() method.
 
    )r¨r–rJr©r|rOrÃr¨rr–rPrJzDeque[_ListenerFnType]r©zSet[_ListenerFnType]r|rrªcCsP||jkr| |¡d|_d|_|j||_||_|j|_t ¡|_    t
ƒ|_ dSr@) rNrvrÁrÂr¨r–rJr…r†r©rŠr|r¬r.r.r/r`s
 
 
z_ListenerCollection.__init__r¥r­rcCs|S)zžReturn an event collection which can be modified.
 
        For _ListenerCollection at the instance level of
        a dispatcher, this returns self.
 
        r.r“r.r.r/r”s    z_ListenerCollection.for_modifyTr?r7)r<Úonly_propagater)cs\ˆj}t|ƒ‰ˆj |j¡‡‡‡fdd„|jDƒ}| |¡|j |¡}t ˆ||¡dS)zIPopulate from the listeners in another :class:`_Dispatch`
        object.cs&g|]}|ˆkrˆr|ˆjkr|‘qSr.)r|)r‚Úl©Zexisting_listener_setrÍr-r.r/r„-s
 
üz/_ListenerCollection._update.<locals>.<listcomp>N)r©rŠr|rjr=ÚunionrZ_stored_in_collection_multi)r-r<rÍZexisting_listenersZother_listenersZ to_associater.rÏr/Ú_update%sþ
 z_ListenerCollection._updatermr{cCs$| ||j¡r |r |j |j¡dSr*)Zprepend_to_listr©r|Úaddrwrr.r.r/r€:sz_ListenerCollection.insertcCs$| ||j¡r |r |j |j¡dSr*)Zappend_to_listr©r|rÒrwrr.r.r/r:?sz_ListenerCollection.appendrˆcCs,|j |j¡|j |j¡t ||¡dSr*)r©r>rwr|Údiscardrr‰r¤r.r.r/r>Dsz_ListenerCollection.remover(cCs&t ||j¡|j ¡|j ¡dSr*)rrŒr©r|rDr,r.r.r/rDIs
z_ListenerCollection.clearN)T) r1r2r3r]r4r5r`r”rÑr€r:r>rDr.r.r.r/r®ös
          ÿr®c@sÀeZdZUdZded<ded<ded<ded    <ddd
d œd d „ZejsXeddœdd„ƒZ    ddddœdd„Z
dddœdd„Z ddddœdd„Z ddddœdd „Z ddd!œd"d#„Zddœd$d%„Zd&S)'r°)Úparent_dispatchrJÚlocalr¨r¥rÔrPrJr¦rÕrÃr¨z_EmptyListener[_ET])rÔrJrÕcCs$d|_||_||_||_|j|_dSr@)rÁrÔrJrÕr¨)r-rÔrJrÕr.r.r/r`Ws
z_JoinedListener.__init__r(cCst|j|jƒSr*)r\rÔrJr,r.r.r/r©jsz_JoinedListener.listenersrr?racCs|j ||¡Sr*)rÕrer—r.r.r/rensz_JoinedListener._adjust_fn_specz_JoinedListener[_ET]rcCs|j |¡|_|_|Sr*)rÕr”r¨r“r.r.r/r”ssz_JoinedListener.for_modifyrmr7r{cCs|j ||¡dSr*)rÕr€rr.r.r/r€wsz_JoinedListener.insertcCs|j ||¡dSr*)rÕr:rr.r.r/r:zsz_JoinedListener.appendrˆcCs|j |¡dSr*)rÕr>r¤r.r.r/r>}sz_JoinedListener.removecCs
tƒ‚dSr*ršr,r.r.r/rD€sz_JoinedListener.clearN)r1r2r3r4r5r`ÚtypingÚ TYPE_CHECKINGÚpropertyr©rer”r€r:r>rDr.r.r.r/r°Os
 r°)9r]Ú
__future__rr…Ú    itertoolsrrÅÚtypesrrÖrrrrr    r
r r r rrrrrrrrr+ÚrrrrrrrZutil.concurrencyrZ util.typingr r!r×Úbaser#r$r%Z MemoizedSlotsr&r6Z_ListenerFnSequenceTyperHr•r§r¹r¿r®r°r.r.r.r/Ú<module>sb                                      7V `Y