hjA>SrSSKrSSKJrJrJr "SS5r"SS\5r\"5r"SS \5r \ "5r \R\R4r 0r0r0r\\S 4S jr\\S 4S jr\\4S jrSr\\4Sjr\\ 4Sjr\\ 4SjrSrSrSrSrSrSrg)aMultiple-producer-multiple-consumer signal-dispatching dispatcher is the core of the PyDispatcher system, providing the primary API and the core logic for the system. Module attributes of note: Any -- Singleton used to signal either "Any Sender" or "Any Signal". See documentation of the _Any class. Anonymous -- Singleton used to signal "Anonymous Sender" See documentation of the _Anonymous class. Internal attributes: WEAKREF_TYPES -- tuple of types/classes which represent weak references to receivers, and thus must be de- referenced on retrieval to retrieve the callable object connections -- { senderkey (id) : { signal : [receivers...]}} senders -- { senderkey (id) : weakref(sender) } used for cleaning up sender references on sender deletion sendersBack -- { receiverkey (id) : [senderkey (id)...] } used for cleaning up receiver references on receiver deletion, (considerably speeds up the cleanup process vs. the original code.) N)saferef robustapplyerrorsc\rSrSrSrSrSrg) _Parameterz+Used to represent default parameter values.c.URR$N) __class____name__)selfs \/root/1688_scrapy/alibaba-scraper/venv/lib/python3.13/site-packages/pydispatch/dispatcher.py__repr___Parameter.__repr__!s~~&&&N)r __module__ __qualname____firstlineno____doc__r__static_attributes__rrrrrs 5'rrc\rSrSrSrSrg)_Any$zSingleton used to signal either "Any Sender" or "Any Signal" The Any object can be used with connect, disconnect, send, or sendExact to signal that the parameter given Any should react to all senders/signals, not just a particular sender/signal. rNr rrrrrrrrrr$srrc\rSrSrSrSrg) _Anonymous.aSingleton used to signal "Anonymous Sender" The Anonymous object is used to signal that the sender of a message is not specified (as distinct from being "any sender"). Registering callbacks for Anonymous will only receive messages sent without senders. Sending with anonymous will only send messages to those receivers registered for Any or Anonymous. Note: The default sender for connect is Any, while the default sender for send is Anonymous. This has the effect that if you do not specify any senders in either function then all messages are routed as though there was a single sender (Anonymous) being used everywhere. rNrrrrrr.srrTcJUc[R"SU<SU<S35eU(a[R"U[S9n[ U5nU[ ;a [ UnO 0=[ U'nUS[[4;a&U4Sjn[R"X&5nU[U'[ U5nX;aXQn [XAX 5 O/=oU'[RU5n U c /=[U'n XJ;aU RU5 U RU5 g! Nw=f! N=f)a3Connect receiver to sender for signal receiver -- a callable Python object which is to receive messages/signals/events. Receivers must be hashable objects. if weak is True, then receiver must be weak-referencable (more precisely saferef.safeRef() must be able to create a reference to the receiver). Receivers are fairly flexible in their specification, as the machinery in the robustApply module takes care of most of the details regarding figuring out appropriate subsets of the sent arguments to apply to a given receiver. Note: if receiver is itself a weak reference (a callable), it will be de-referenced by the system's machinery, so *generally* weak references are not suitable as receivers, though some use might be found for the facility whereby a higher-level library passes in pre-weakrefed receiver references. signal -- the signal to which the receiver should respond if Any, receiver will receive any signal from the indicated sender (which might also be Any, but is not necessarily Any). Otherwise must be a hashable Python object other than None (DispatcherError raised on None). sender -- the sender to which the receiver should respond if Any, receiver will receive the indicated signals from any sender. if Anonymous, receiver will only receive indicated signals from send/sendExact which do not specify a sender, or specify Anonymous explicitly as the sender. Otherwise can be any python object. weak -- whether to use weak references to the receiver By default, the module will attempt to use weak references to the receiver objects. If this parameter is false, then strong references will be used. returns None, may raise DispatcherTypeError N Signal cannot be None (receiver= sender=))onDeletec[US9 g)N senderkey) _removeSender)objectr&s rremoveconnect..removes I .r)rDispatcherTypeErrorrsafeRef_removeReceiverid connections AnonymousAnyweakrefrefsenders_removeOldBackRefs sendersBackgetappend) receiversignalsenderweakr&signalsr) weakSender receiverID receiverscurrents rconnectrBIs&h~((>Fv N   ??8oF6 IKi(+-- IdIs++%. /  V4J!+GI HJO 9hB&(( FO //:/ ?24 4K %  # NN9 %X)     sD 9DDD"c Uc[R"SU<SU<S35eU(a[R"U5n[ U5n[ UnXQn[XAX5 [XA5 g![ a [R"SU<SU<35ef=f![a# [R"SU<SU<SU<35ef=f) aaDisconnect receiver from sender for signal receiver -- the registered receiver to disconnect signal -- the registered signal to disconnect sender -- the registered sender to disconnect weak -- the weakref state to disconnect disconnect reverses the process of connect, the semantics for the individual elements are logically equivalent to a tuple of (receiver, signal, sender, weak) used as a key to be deleted from the internal routing tables. (The actual process is slightly more complex but the semantics are basically the same). Note: Using disconnect is not required to cleanup routing when an object is deleted, the framework will remove routes for deleted objects automatically. It's only necessary to disconnect if you want to stop routing to a live object. returns None, may raise DispatcherTypeError or DispatcherKeyError Nr r!r"zNo receivers found for signal z from sender zNo connection to receiver z for signal ) rr+rr,r.r/KeyErrorDispatcherKeyErrorr5 ValueError_cleanupConnections)r9r:r;r<r&r=r@s r disconnectrHs4~((>Fv N   1X6 I  i(O   9hB *%  ''      ''    s A2 B2)B-C cR[[U5U$![a /s$f=f)a#Get list of receivers from global tables This utility function allows you to retrieve the raw list of receivers from the connections table for the given sender and signal pair. Note: there is no guarantee that this is the actual list stored in the connections table, so the value should be treated as a simple iterable/truth value rather than, for instance a list to which you might append new records. Normally you would use liveReceivers( getReceivers( ...)) to retrieve the actual receiver objects as an iterable object. )r/r.rD)r;r:s r getReceiversrJs/$2f:&v..  s  &&c#t# UH.n[U[5(aU"5nUbUv M(M*Uv M0 g7f)zFilter sequence of receivers to get resolved, live receivers This is a generator which will iterate over the passed sequence, checking for weak references and resolving them, then returning all live receivers. N) isinstance WEAKREF_TYPES)r@r9s r liveReceiversrNs< x / /zH#$Ns68c## 0n[X5[U[5[[U5[[[54H%nUHnU(dM XB;a SX$'Uv MM M' g![a M2f=f7f)zGet list of all receivers from global tables This gets all receivers which should receive the given signal from sender, each receiver should be produced only once by the resulting generator N)rJr1 TypeError)r;r:r@setr9s rgetAllReceiversrS sI f&fc#c6#c3  Hx0./ +&1  !s*A A= A,! A=, A:6A=9A::A=c/n[[X55H2n[R"U/UQ7UUS.UD6nUR XV45 M4 U$)aySend signal from sender to all connected receivers. signal -- (hashable) signal value, see connect for details sender -- the sender of the signal if Any, only receivers registered for Any will receive the message. if Anonymous, only receivers registered to receive messages from Anonymous or Any will receive the message Otherwise can be any python object (normally one registered with a connect if you actually want something to occur). arguments -- positional arguments which will be passed to *all* receivers. Note that this may raise TypeErrors if the receivers do not allow the particular arguments. Note also that arguments are applied before named arguments, so they should be used with care. named -- named arguments which will be filtered according to the parameters of the receivers to only provide those acceptable to the receiver. Return a list of tuple pairs [(receiver, response), ... ] if any receiver raises an error, the error propagates back through send, terminating the dispatch loop, so it is quite possible to not have all receivers called if a raises an error. r:r;)rNrSr robustApplyr8r:r; argumentsnamed responsesr9responses rsendr\'slHI!/&"AB**        (-.C rc/n[[X55H2n[R"U/UQ7UUS.UD6nUR XV45 M4 U$)zSend signal only to those receivers registered for exact message sendExact allows for avoiding Any/Anonymous registered handlers, sending only to those receivers explicitly registered for a particular signal on a particular sender. rU)rNrJrrVr8rWs r sendExactr^VskI!,v">?**        (-.@ rc[(dg[U5n[RU5nUHWn[[UR 55nUH-n[UUnUR U5 [X55 M/ MY g![a N f=f![a N0f=f![a Mf=f![a gf=f)z!Remove receiver from connections.FN) r6r.poplistr/keysr) ExceptionrDrG)r9backKeybackSetr&r=r:r@s rr-r-ks ;lG;//'*!I ;{95::<=&F!$/ $:6$B !%,,h8( :& ! )! ! $    sFB= B, B'B  BB B)(B), B:9B:= C  C c[UUnU(d [UnX1 U(d [U5 ggg![a gf=f! g=f)zBDelete any empty signals for senderkey. Delete senderkey if empty.N)r/r'rD)r&r:r@r=s rrGrGsc- *62  -%i0O!),    s A 6 AAA ch[U5 [U [U g![a Nf=f! g=f)z"Remove senderkey from connections.N)_removeBackrefsr/rDr4r%s rr'r'sAI  "  I       s- **1c^[UnUR5mU4SjnU"5Hn[X05 M g![a Sngf=f)z,Remove all back-references to this senderkeyc3>># THupUHnUv M M g7fr r)r:rRitemitemss r allReceivers%_removeBackrefs..allReceiverss!# DJ $sN)r/rl _killBackrefrD)r&r=rmr9rls @rrhrhsP 0i(  %H ( /' s < A  A c:URU5nX4nX4 Sn[RU5nUbF[RU05R5HupX:wdM U H n XLdM Sn M M U(d [ XP5 gg![ a gf=f)zKill old sendersBack references from receiver This guards against multiple registration of the same receiver for a given signal and sender leaking memory as old back reference records build up. Also removes old receiver instance from receivers rrPTF)indexr/r7rlrorF) r&r:r9r@rq oldReceiverfoundr=sigrecsrecs rr5r5s)  &  //&)  'OOF26<<>=#-$%E! $?  + 2# sB BBc[U5n[RUS5nX;aURU5 X;aMU(d [U gg! M=f![a gf=f)zBDo the actual removal of back reference from receiver to senderkeyrT)r.r6r7r)rD)r9r& receiverkeyrRs rrorosqX,K //; ,C    JJ #    [*       sAAA A&%A&)rr2 pydispatchrrrrrr1rr0 ReferenceTypeBoundMethodWeakrefrMr/r4r6rBrHrJrNrSr\r^r-rGr'rhr5rorrrr|s633'' : f$ L &&(B(BC   !4]B!$Cd5+n.&"C8I.^)*;:-&   0@r