vKg@P(SrSSKJr SSKrSSKJr SSKJr SSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr \R.(aSSKr\R4"S\R6S\R84S9r\R4"S5r\R>"S5r \R6\R6\ \RB\4/\R6\ \44r"\R6\R6\ \4/\R6\ \RB\44r#\"S5r$S\$lSr%\RLr&"SS5r'\'"S5r("SS\'5r)"SS\*5r+"SS\5r,\+"5RZr-g) a+Signals and events. A small implementation of signals, inspired by a snippet of Django signal API client code seen in a blog post. Signals are first-class objects and each manages its own receivers and message emission. The :func:`signal` function provides singleton behavior for named signals. ) annotationsN) defaultdict)contextmanager)iscoroutinefunction)warn)WeakValueDictionary)annotatable_weakref)hashable_identity) IdentityType) lazy_property) reference)symbol) WeakTypes T_callable.)boundTPANYzToken for "any sender".c\rSrSr%Sr\r\rS\S'\ SSj5r \ SSj5r SSSjjr \S 4S S jjr S!S"S jjr\\4S#S jj5r\S$S j5r\4S%SjjrSS.S&SjjrSS.S'SjjrS(SjrS)SjrS*Sjr\4S+SjjrS,SjrS-SjrS.SjrS/SjrS/SjrSrg)0Signal/zA notification emitter.z type[set] set_classc[SS9$)zEmitted after each :meth:`connect`. The signal sender is the signal instance, and the :meth:`connect` arguments are passed through: *receiver*, *sender*, and *weak*. .. versionadded:: 1.2 z"Emitted after a receiver connects.docrselfs L/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/blinker/base.pyreceiver_connectedSignal.receiver_connected8s>??c[SS9$)aEmitted after :meth:`disconnect`. The sender is the signal instance, and the :meth:`disconnect` arguments are passed through: *receiver* and *sender*. Note, this signal is emitted **only** when :meth:`disconnect` is called explicitly. The disconnect signal can not be emitted by an automatic disconnect (due to a weakly referenced receiver or sender going out of scope), as the receiver and/or sender instances are no longer available for use at the time this signal would be emitted. An alternative approach is available by subscribing to :attr:`receiver_connected` and setting up a custom weakref cleanup callback on weak receivers and senders. .. versionadded:: 1.2 z%Emitted after a receiver disconnects.rrrs rreceiver_disconnectedSignal.receiver_disconnectedDs,ABBr"NcU(aXl0UlSUl[UR5Ul[UR5Ul0Ulg)z\ :param doc: optional. If provided, will be assigned to the signal's __doc__ attribute. FN)__doc__ receiversis_mutedrr _by_receiver _by_sender _weak_senders)rrs r__init__Signal.__init__\sW LPR CN NND BM NNB GIr"Tc[U5nU(a[XR5nXElOUnU[La[ nO [U5nUR RXE5 URURU5 URURU5 AU[LaGX`R;a8[X R5nXgl URRXg5 ASUR;a6UR R (aUR R#XX#S9 [ R (a U[ La[ R#XX#S9 U$U$![a Nf=f![anUR%X5 UeSnAff=f![anUR%X5 UeSnAff=f)aConnect *receiver* to signal events sent by *sender*. :param receiver: A callable. Will be invoked by :meth:`send` with `sender=` as a single positional argument and any ``kwargs`` that were provided to a call to :meth:`send`. :param sender: Any object or :obj:`ANY`, defaults to ``ANY``. Restricts notifications delivered to *receiver* to only those :meth:`send` emissions sent by *sender*. If ``ANY``, the receiver will always be notified. A *receiver* may be connected to multiple *sender* values on the same Signal through multiple calls to :meth:`connect`. :param weak: If true, the Signal will hold a weakref to *receiver* and automatically disconnect when *receiver* goes out of scope or is garbage collected. Defaults to True. r )receiversenderweakN) receiver_arg sender_argweak_arg)r r _cleanup_receiver receiver_idrANY_IDr( setdefaultr+addr*r,_cleanup_sender sender_id TypeError__dict__r send disconnect) rr0r1r2r7 receiver_refr< sender_refes rconnectSignal.connectts*(1  $X/E/EFL'2 $#L S=I)&1I !!+<  "&&{3 +&**95   2D2D!D &v/C/CD '0$""--iD 4== 0T5L5L5V5V '',,F-  ' 'D8J,J "''F( x/   1  1 sB=E1 FF&1 E>=E> F# FF#& G0GGc ^^^SUUU4SjjnU$)aConnect the decorated function as a receiver for *sender*. :param sender: Any object or :obj:`ANY`. The decorated function will only receive :meth:`send` emissions sent by *sender*. If ``ANY``, the receiver will always be notified. A function may be decorated multiple times with differing *sender* values. :param weak: If true, the Signal will hold a weakref to the decorated function and automatically disconnect when *receiver* goes out of scope or is garbage collected. Unlike :meth:`connect`, this defaults to False. The decorated function will be invoked by :meth:`send` with `sender=` as a single positional argument and any ``kwargs`` that were provided to the call to :meth:`send`. .. versionadded:: 1.1 c.>TRUTT5 U$N)rD)fnrr1r2s r decorator%Signal.connect_via..decorators LLVT *Ir")rIrreturnr)rr1r2rJs``` r connect_viaSignal.connect_vias0  r"c## URXSS9 Sv URU5 g!URU5 f=f7f)aExecute a block with the signal temporarily connected to *receiver*. :param receiver: a receiver callable :param sender: optional, a sender to filter on This is a context manager for use in the ``with`` statement. It can be useful in unit tests. *receiver* is connected to the signal for the duration of the ``with`` block, and will be disconnected automatically when exiting the block: .. code-block:: python with on_ready.connected_to(receiver): # do stuff on_ready.send(123) .. versionadded:: 1.1 F)r1r2N)rDr@rr0r1s r connected_toSignal.connected_tos9. X5 9 &J OOH %DOOH %sA*A=Ac#t# SUlSv SUlg![anUeSnAff=f!SUlf=f7f)zLContext manager for temporarily disabling signal. Useful for test purposes. TNF)r) Exception)rrCs rmuted Signal.mutedsA   "J"DM G "DMs$88 )$), 58cD[S[5 URX5$)a/An alias for :meth:`connected_to`. :param receiver: a receiver callable :param sender: optional, a sender to filter on .. versionadded:: 0.9 .. versionchanged:: 1.1 Renamed to :meth:`connected_to`. ``temporarily_connected_to`` was deprecated in 1.2 and will be removed in a subsequent version. zAtemporarily_connected_to is deprecated; use connected_to instead.)rDeprecationWarningrRrQs rtemporarily_connected_toSignal.temporarily_connected_tos% O    22r")_async_wrappercUR(a/$URU5n/nURU5HDn[U5(aUc [ S5eU"U5nU"U40UD6nUR XV45 MF U$)aEmit this signal on behalf of *sender*, passing on ``kwargs``. Returns a list of 2-tuples, pairing receivers with their return value. The ordering of receiver notification is undefined. :param sender: Any object or ``None``. If omitted, synonymous with ``None``. Only accepts one positional argument. :param _async_wrapper: A callable that should wrap a coroutine receiver and run it when called synchronously. :param kwargs: Data to be sent to receivers. z#Cannot send to a coroutine functionr)_extract_sender receivers_forr RuntimeErrorappend)rr\r1kwargsresultsr0results rr? Signal.sends$ ==I%%f-**62H"8,,!)&'LMM)(3f//F NNH- . 3r") _sync_wrapperc # UR(a/$URU5n/nURU5HLn[U5(dUc [ S5eU"U5nU"U40UD6IShvN nUR XV45 MN U$N7f)aEmit this signal on behalf of *sender*, passing on ``kwargs``. Returns a list of 2-tuples, pairing receivers with their return value. The ordering of receiver notification is undefined. :param sender: Any object or ``None``. If omitted, synonymous with ``None``. Only accepts one positional argument. :param _sync_wrapper: A callable that should wrap a synchronous receiver and run it when awaited. :param kwargs: Data to be sent to receivers. Nz'Cannot send to a non-coroutine functionr^)rrgr1rcrdr0res r send_asyncSignal.send_async7s$ ==I%%f-**62H&x00 (&'PQQ(2#F5f55F NNH- . 36sA-B/B 0BcUR(d0U(a'[U5S:a[S[U5S35e/$[U5S:XaSnU$[U5S:a[S[U5S35eUSnU$)Nz-send() accepts only one positional argument, z givenr)r(lenr=rr1s rr_Signal._extract_senderWs~~$F aCCK=PVWI v;! F [1_?F }FS AYF r"cUR(dgUR[(agU[Lag[ U5UR;$)zTrue if there is probably a receiver for *sender*. Performs an optimistic check only. Does not guarantee that all weakly referenced receivers are still alive. See :meth:`receivers_for` for a stronger search. FT)r(r+r8rr rns rhas_receivers_forSignal.has_receivers_forns;~~ ??6 " S= (DOO;;r"c## UR(a[U5nX R;a$UR[URU-nO!UR[R 5nUH`nURR U5nUcM#[ U[5(a$U"5nUcURU[5 MZUnUv Mb gg7f)z2Iterate all live receivers listening for *sender*.N) r(r r+r8copyget isinstancer _disconnect)rr1r<idsr7r0strongs rr`Signal.receivers_for~s >>)&1IOO+oof- 0JJoof-224" >>--k:#h 22%ZF~((f= %H # sCCcU[La[nO [U5n[U5nURXC5 SUR;a7UR R (aUR RXUS9 ggg)zDisconnect *receiver* from this signal's events. :param receiver: a previously :meth:`connected` callable :param sender: a specific sender to disconnect from, or :obj:`ANY` to disconnect from all senders. Defaults to ``ANY``. r$)r0r1N)rr8r rwr>r$r(r?)rr0r1r<r7s rr@Signal.disconnectsr S=I)&1I'1  0 $t}} 4**44  & & + +DF + S5 5r"cpU[:XapURRUS5(a2URR 5HnUR U5 M UR RUS5 gURUR U5 URUR U5 g)NF)r8r*popr+valuesdiscardr()rr7r<buckets rrwSignal._disconnects    $$[%88"oo446FNN;/7 NN  {D 1 OOI & . .{ ;   k * 2 29 =r"c`UR[[UR5[5 g)z'Disconnect a receiver from all senders.N)rwcastr r7r8)rrAs rr6Signal._cleanup_receivers lL,D,DEvNr"c [[UR5nU[:wdeURR US5 UR R US5H!nURURU5 M# g)z'Disconnect all receivers from a sender.NrM) rr r<r8r,r~r+r*r)rrBr<r7s rr;Signal._cleanup_senderslz';';< F""" y$/??..y"=K   k * 2 29 =>r"cURUR4H@n[UR55H up#U(aMUR US5 M" MB g)aPrune unused sender/receiver bookkeeping. Not threadsafe. Connecting & disconnecting leave behind a small amount of bookkeeping for the receiver and sender values. Typical workloads using Blinker, for example in most web apps, Flask, CLI scripts, etc., are not adversely affected by this bookkeeping. With a long-running Python process performing dynamic signal routing with high volume- e.g. connecting to function closures, "senders" are all unique object instances, and doing all of this over and over- you may see memory usage will grow due to extraneous bookkeeping. (An empty set() for each stale sender/receiver pair.) This method will prune that bookkeeping away, with the caveat that such pruning is not threadsafe. The risk is that cleanup of a fully disconnected receiver/sender pair occurs while another thread is connecting that same pair. If you are in the highly dynamic, unique receiver/sender situation that has lead you to this method, that failure mode is perhaps not a big deal for you. N)r+r*listitemsr~)rmapping_idrs r_cleanup_bookkeepingSignal._cleanup_bookkeepingsG*):):;G#GMMO4 vKKT* 5O>+4"r"ra Sent by a :class:`Signal` after a receiver connects. :argument: the Signal that was connected to :keyword receiver_arg: the connected receiver :keyword sender_arg: the sender to connect to :keyword weak_arg: true if the connection to receiver_arg is a weak reference .. deprecated:: 1.2 As of 1.2, individual signals have their own private :attr:`~Signal.receiver_connected` and :attr:`~Signal.receiver_disconnected` signals with a slightly simplified call signature. This global signal is planned to be removed in 1.6. c0\rSrSrSrSSSjjrS SjrSrg) NamedSignaliz%A named generic notification emitter.Nc:[RX5 XlgrH)rr-name)rrrs rr-NamedSignal.__init__s" r"cX[RU5nUSSSUR<S3$)Nz; >)r__repr__r)rbases rrNamedSignal.__repr__s-t$s)Btyym1--r")rrH)rstrrrrLr)rLr)rrrrr'r-rrrMr"rrrs/ .r"rc&\rSrSrSrSSSjjrSrg) Namespaceiz%A mapping of signal names to signals.NcfX$![a URU[X55nUs$f=fzReturn the :class:`NamedSignal` *name*, creating it if required. Repeated calls to this function will return the same signal object. KeyErrorr9rrrrres rsignalNamespace.signal 8  :  __T;t+ABFM  '00rMrHrrrrrLrrrrrr'rrrMr"rrrs/  r"rc&\rSrSrSrSSSjjrSrg) WeakNamespaceiaA weak mapping of signal names to signals. Automatically cleans up unused Signals when the last reference goes out of scope. This namespace implementation exists for a measure of legacy compatibility with Blinker <= 1.2, and may be dropped in the future. .. versionadded:: 1.3 NcfX$![a URU[X55nUs$f=frrrs rrWeakNamespace.signal!rrrMrHrrrMr"rrrs  r"r).r' __future__rtypingt collectionsr contextlibrinspectrwarningsrweakrefrblinker._utilitiesr r r r r rr TYPE_CHECKINGtyping_extensionsteTypeVarCallableAnyrr ParamSpecr AwaitableAsyncWrapperTypeSyncWrapperTyperr8rrr rdictrrrrMr"rrsc##%''20+,(%(??"@Q5R!RSO Um'  vvr"r"j ( .& .   '0   r"