⚝
One Hat Cyber Team
⚝
Your IP:
216.73.216.144
Server IP:
157.245.143.252
Server:
Linux www 6.11.0-9-generic #9-Ubuntu SMP PREEMPT_DYNAMIC Mon Oct 14 13:19:59 UTC 2024 x86_64
Server Software:
nginx/1.26.0
PHP Version:
8.3.11
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
lib
/
python3
/
dist-packages
/
blinker
/
__pycache__
/
View File Name :
base.cpython-312.pyc
&=f.X , U d dl mZ d dlmZ d dlZd dlZd dlZd dl m Z d dl m Z d dl m Z d dlmZ d dlmZ d dlmZ d d lmZ d d lmZ d d lmZ ej. r- ej0 d ej2 dej4 f Z ed Z d Z G d d Z e d Z G d de Z ej. r G d dejB Z"e#e$e f Z%ne#Z% G d de% Z& G d de Z' e& Z(de)d < e(jT Z*de)d < d d Z+y) ) annotationsN) defaultdict)AbstractContextManager)contextmanager)cached_property)iscoroutinefunction)WeakValueDictionary )make_id)make_ref)SymbolF.)boundANYc R e Zd ZU dZeZ eZded< edd Z edd Z dd dZ edfd d Z d d d Z eef d d Zed!d Zef d"d Z ddd d#dZ ddd d$dZd%dZ d&dZefd'dZd(dZ d)dZ d*dZd+dZd+dZy),SignalzKA notification emitter. :param doc: The docstring for the signal. ztype[set[t.Any]] set_classc t d S )zEmitted at the end of each :meth:`connect` call. 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.docr selfs ./usr/lib/python3/dist-packages/blinker/base.pyreceiver_connectedzSignal.receiver_connected, s >?? c t d S )a Emitted at the end of each :meth:`disconnect` call. The sender is the signal instance, and the :meth:`disconnect` arguments are passed through: ``receiver`` and ``sender``. This signal is emitted **only** when :meth:`disconnect` is called explicitly. This signal cannot be emitted by an automatic disconnect when a weakly referenced receiver or sender goes out of scope, as the instance is no longer be available to be used as the sender for this signal. 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.r r r s r receiver_disconnectedz Signal.receiver_disconnected7 s & ABBr Nc |r|| _ i | _ d| _ t | j | _ t | j | _ i | _ y )NF)__doc__ receiversis_mutedr r _by_receiver _by_sender _weak_senders)r r s r __init__zSignal.__init__L sO DL $ 5@ 5P3>t~~3N>@r Tc F t | }|t u rt n t | }|r)t || j | | j |< n|| j |< | j | j | | j | j | |t ur7|| j vr) t || j | | j |< d| j v r6| j j r | j j | ||| t j r$| t ur t j | ||| |S |S # t $ r Y w xY w# t $ r | j || w xY w# t $ r | j || w xY w)a Connect ``receiver`` to be called when the signal is sent by ``sender``. :param receiver: The callable to call when :meth:`send` is called with the given ``sender``, passing ``sender`` as a positional argument along with any extra keyword arguments. :param sender: Any object or :data:`ANY`. ``receiver`` will only be called when :meth:`send` is called with this sender. If ``ANY``, the receiver will be called for any sender. A receiver may be connected to multiple senders by calling :meth:`connect` multiple times. :param weak: Track the receiver with a :mod:`weakref`. The receiver will be automatically disconnected when it is garbage collected. When connecting a receiver defined within a function, set to ``False``, otherwise it will be disconnected when the function scope ends. r )receiversenderweak) receiver_arg sender_argweak_arg)r r ANY_IDr _make_cleanup_receiverr! r$ addr# r% _make_cleanup_sender TypeError__dict__r send disconnect_receiver_connected)r r( r) r* receiver_id sender_ids r connectzSignal.connect^ s h' $mF *2$55kB+DNN; ' +3DNN; ' "&&{3 +&**95 $2D2D!D 08D 5 5i @1""9- 4== 0T5L5L5V5V '',,8F - ( (T9L-L #((xFT ) x- &1 &1 s* 2(E ? E# 7F E E # F F c d fd }|S )a Connect the decorated function to be called when the signal is sent by ``sender``. The decorated function will be called when :meth:`send` is called with the given ``sender``, passing ``sender`` as a positional argument along with any extra keyword arguments. :param sender: Any object or :data:`ANY`. ``receiver`` will only be called when :meth:`send` is called with this sender. If ``ANY``, the receiver will be called for any sender. A receiver may be connected to multiple senders by calling :meth:`connect` multiple times. :param weak: Track the receiver with a :mod:`weakref`. The receiver will be automatically disconnected when it is garbage collected. When connecting a receiver defined within a function, set to ``False``, otherwise it will be disconnected when the function scope ends.= .. versionadded:: 1.1 c . j | | S N)r9 )fnr r) r* s r decoratorz%Signal.connect_via.<locals>.decorator s LLVT *Ir )r= r returnr )r r) r* r> s ``` r connect_viazSignal.connect_via s ( r c # K | j ||d d | j | y# | j | w xY ww)a A context manager that temporarily connects ``receiver`` to the signal while a ``with`` block executes. When the block exits, the receiver is disconnected. Useful for tests. :param receiver: The callable to call when :meth:`send` is called with the given ``sender``, passing ``sender`` as a positional argument along with any extra keyword arguments. :param sender: Any object or :data:`ANY`. ``receiver`` will only be called when :meth:`send` is called with this sender. If ``ANY``, the receiver will be called for any sender. .. versionadded:: 1.1 F)r) r* N)r9 r5 r r( r) s r connected_tozSignal.connected_to s< " Xf5 9 &J OOH %DOOH %s A. AAAc # J K d| _ d d| _ y# d| _ w xY ww)zA context manager that temporarily disables the signal. No receivers will be called if the signal is sent, until the ``with`` block exits. Useful for tests. TNF)r" r s r mutedz Signal.muted s' "J !DMEDMs # # #c ^ t j dt d | j || S )zDeprecated alias for :meth:`connected_to`. .. deprecated:: 1.1 Renamed to ``connected_to``. Will be removed in Blinker 1.9. .. versionadded:: 0.9 zw'temporarily_connected_to' is renamed to 'connected_to'. The old name is deprecated and will be removed in Blinker 1.9. stacklevel)warningswarnDeprecationWarningrD rC s r temporarily_connected_toz Signal.temporarily_connected_to s0 > 622r )_async_wrapperc | j rg S g }| j | D ]F }t | r | t d || |fi |}n ||fi |}|j ||f H |S )a/ Call all receivers that are connected to the given ``sender`` or :data:`ANY`. Each receiver is called with ``sender`` as a positional argument along with any extra keyword arguments. Return a list of ``(receiver, return value)`` tuples. The order receivers are called is undefined, but can be influenced by setting :attr:`set_class`. If a receiver raises an exception, that exception will propagate up. This makes debugging straightforward, with an assumption that correctly implemented receivers will not raise. :param sender: Call receivers connected to this sender, in addition to those connected to :data:`ANY`. :param _async_wrapper: Will be called on any receivers that are async coroutines to turn them into sync callables. For example, could run the receiver with an event loop. :param kwargs: Extra keyword arguments to pass to each receiver. .. versionchanged:: 1.7 Added the ``_async_wrapper`` argument. z$Cannot send to a coroutine function.r" receivers_forr RuntimeErrorappend)r r) rO kwargsresultsr( results r r4 z Signal.send s B ==I **62H"8,!)&'MNN1 1&CFC!&3F3 NNHf- . 3 r ) _sync_wrapperc K | j rg S g }| j | D ]V }t | s%| t d || |fi | d{ }n ||fi | d{ }|j ||f X |S 7 -7 w)a Await all receivers that are connected to the given ``sender`` or :data:`ANY`. Each receiver is called with ``sender`` as a positional argument along with any extra keyword arguments. Return a list of ``(receiver, return value)`` tuples. The order receivers are called is undefined, but can be influenced by setting :attr:`set_class`. If a receiver raises an exception, that exception will propagate up. This makes debugging straightforward, with an assumption that correctly implemented receivers will not raise. :param sender: Call receivers connected to this sender, in addition to those connected to :data:`ANY`. :param _sync_wrapper: Will be called on any receivers that are sync callables to turn them into async coroutines. For example, could call the receiver in a thread. :param kwargs: Extra keyword arguments to pass to each receiver. .. versionadded:: 1.7 Nz(Cannot send to a non-coroutine function.rQ )r r) rX rU rV r( rW s r send_asynczSignal.send_async s @ ==I **62H&x0 (&'QRR 6}X 6v H HH ' 9& 99 NNHf- . 3 I9s$ ABA?B#B$ BBc | j sy| j t ry|t u ryt | | j v S )a Check if there is at least one receiver that will be called with the given ``sender``. A receiver connected to :data:`ANY` will always be called, regardless of sender. Does not check if weakly referenced receivers are still live. See :meth:`receivers_for` for a stronger search. :param sender: Check for receivers connected to this sender, in addition to those connected to :data:`ANY`. FT)r! r$ r. r r )r r) s r has_receivers_forzSignal.has_receivers_forO s: ~~ ??6 " S=v$//11r c # K | j syt | }|| j v r$| j t | j | z }n!| j t j }|D ]c }| j j | }|!t |t j r% | }|| j |t [| `| e yw)aI Yield each receiver to be called for ``sender``, in addition to those to be called for :data:`ANY`. Weakly referenced receivers that are not live will be disconnected and skipped. :param sender: Yield receivers connected to this sender, in addition to those connected to :data:`ANY`. N) r! r r$ r. copyget isinstanceweakrefref _disconnect)r r) r8 idsr7 r( strongs r rR zSignal.receivers_ford s ~~ FO '//&)DOOI,FFC//&)..0C K~~))+6H (GKK0!>$$[&9 s CCc |t u rt }n t | }t | }| j || d| j v r6| j j r | j j | || yyy)a Disconnect ``receiver`` from being called when the signal is sent by ``sender``. :param receiver: A connected receiver callable. :param sender: Disconnect from only this sender. By default, disconnect from all senders. r )r( r) N)r r. r rc r3 r r! r4 )r r( r) r8 r7 s r r5 zSignal.disconnect su S= I I h' i0 $t}} 4**44 & & + +D8F + S 5 5r c ` |t k( ri| j j |d 0| j j D ] }|j | | j j |d y | j | j | | j | j | y r< )r. r# popr$ valuesdiscardr! )r r7 r8 buckets r rc zSignal._disconnect s $$[$7C "oo 4 4 6FNN;/ 7 NN {D 1 OOI & . .{ ; k * 2 29 =r c d fd }|S )ztCreate a callback function to disconnect a weakly referenced receiver when it is garbage collected. c 2 j t y r< )rc r. )rb r7 r s r cleanupz.Signal._make_cleanup_receiver.<locals>.cleanup s [& 1r )rb z#weakref.ref[c.Callable[..., t.Any]]r? Noner@ )r r7 rn s `` r r/ z Signal._make_cleanup_receiver s 2 r c . t k7 sJ d fd }|S )zCreate a callback function to disconnect all receivers for a weakly referenced sender when it is garbage collected. c j j d j j d D ] }j | j " y )Nr@ )r% rh r$ r# rj )rb r7 r r8 s r rn z,Signal._make_cleanup_sender.<locals>.cleanup sN " "9d 3 # 2 29b A !!+.66yA Br )rb zweakref.ref[t.Any]r? ro )r. )r r8 rn s `` r r1 zSignal._make_cleanup_sender s F""" B r c | j | j fD ]8 }t |j D ] \ }}|r |j |d : y)aE Prune unused sender/receiver bookkeeping. Not threadsafe. Connecting & disconnecting leaves behind a small amount of bookkeeping data. 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 process performing dynamic signal routing with high volume, e.g. connecting to function closures, senders are all unique object instances. Doing all of this over and over may cause memory usage to 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# listitemsrh )r mappingidentrk s r _cleanup_bookkeepingzSignal._cleanup_bookkeeping sG * ):):;G!%gmmo!6 v KKt, "7 <r c | j j | j j | j j | j j y)z7Disconnect all receivers and senders. Useful for tests.N)r% clearr! r$ r# r s r _clear_statezSignal._clear_state sF " !r )r? r r< )r str | Noner? ro )r( r r) t.Anyr* boolr? r )F)r) r| r* r} r? zc.Callable[[F], F])r( c.Callable[..., t.Any]r) r| r? c.Generator[None, None, None])r? r )r( r~ r) r| r? z AbstractContextManager[None])r) t.Any | NonerO z^c.Callable[[c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]], c.Callable[..., t.Any]] | NonerU r| r? *list[tuple[c.Callable[..., t.Any], t.Any]])r) r rX z^c.Callable[[c.Callable[..., t.Any]], c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]] | NonerU r| r? r )r) r| r? r} )r) r| r? z/c.Generator[c.Callable[..., t.Any], None, None])r( r~ r) r| r? ro )r7 c.Hashabler8 r r? ro )r7 r r? z7c.Callable[[weakref.ref[c.Callable[..., t.Any]]], None])r8 r r? z&c.Callable[[weakref.ref[t.Any]], None]r? ro ) __name__ __module__ __qualname__r r setr __annotations__r r r r& r9 rA r rD rF rN r4 rZ r\ rR r5 rc r/ r1 rw rz r@ r r r r s C>"%I % @ @ C C(A$ 47T 9v4 @C&.&8=& && &. " " AD3.38=3 %3( $1 1 1 1 1 41j $0 0 0 0 0 40d2*$ $ 8$ L LO T0 > % @ # / -4"r r a 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 Individual signals have their own :attr:`~Signal.receiver_connected` and :attr:`~Signal.receiver_disconnected` signals with a slightly simplified call signature. This global signal will be removed in Blinker 1.9. c 2 e Zd ZdZdd fd Zd fd Z xZS ) NamedSignala A named generic notification emitter. The name is not used by the signal itself, but matches the key in the :class:`Namespace` that it belongs to. :param name: The name of the signal within the namespace. :param doc: The docstring for the signal. c 2 t | | || _ y r< )superr& name)r r r __class__s r r& zNamedSignal.__init__ s r c J t | }|d d d| j dS )Nz; >)r __repr__r )r baser s r r zNamedSignal.__repr__ s- w !s)Btyym1--r r< )r strr r{ r? ro )r? r )r r r r r& r __classcell__r s @r r r s . .r r c e Zd ZdddZy)PNamespaceSignalNc y r< r@ r r r s r __call__zPNamespaceSignal.__call__ s cr r< r r r r{ r? r )r r r r r@ r r r r s Qr r c e Zd ZdZdddZy) Namespacez A dict mapping names to signals.Nc 2 || vrt || | |< | | S zReturn the :class:`NamedSignal` for the given ``name``, creating it if required. Repeated calls with the same name return the same signal. :param name: The name of the signal. :param doc: The docstring of the signal. r r s r signalzNamespace.signal & t $T3/DJDzr r< r )r r r r r r@ r r r r s * r r c . e Zd ZdZd fd ZdddZ xZS )_WeakNamespacea. A weak mapping of names to signals. Automatically cleans up unused signals when the last reference goes out of scope. This namespace implementation provides similar behavior to Blinker <= 1.2. .. deprecated:: 1.3 Will be removed in Blinker 1.9. .. versionadded:: 1.3 c Z t j dt d t | y )NZ'WeakNamespace' is deprecated and will be removed in Blinker 1.9. Use 'Namespace' instead.rH rI )rK rL rM r r& )r r s r r& z_WeakNamespace.__init__7 s' ( r c 2 || vrt || | |< | | S r r r s r r z_WeakNamespace.signal@ r r r r< r )r r r r r& r r r s @r r r * s r r default_namespacer c | dk( r"t j dt d t S | dk( r"t j dt d t S t | )Nr zThe global 'receiver_connected' signal is deprecated and will be removed in Blinker 1.9. Use 'Signal.receiver_connected' and 'Signal.receiver_disconnected' instead.rH rI WeakNamespacer )rK rL rM r6 r AttributeError)r s r __getattr__r Y s^ ## 7 #" ( r )r r r? r| ), __future__r collections.abcabcctypingtrK ra collectionsr contextlibr r functoolsr inspectr r _utilitiesr r r TYPE_CHECKINGTypeVarCallableAnyr r r. r r6 r Protocolr dictr _NamespaceBaser r r r r r r@ r r <module>r s " # - % % ' ' ?? #QZZQUU 34A Um M" M"` ".& .& ??R1:: R #{*+NN ( F ){ 9 * -33 3 r