CasperSecurity
o
_�Kj�J � @ s U d dl mZ d dlmZ d dlZd dlZd dlZd dl m
Z
d dl m Z d dl
mZ d dlmZ ddlmZ dd lmZ dd
lmZ ejd ejd ejf d
�Zed�Z d ZG dd� d�ZG dd� de�Z G dd� de e e f �Z G dd� dej �Z!e � Z"de#d< e"j$Z$de#d< dS )� )� annotationsN)� defaultdict)�contextmanager)�cached_property)�iscoroutinefunction� )�make_id)�make_ref)�Symbol�F.)�bound�ANYc @ s e Zd ZU dZeZ eZded< edEdd��Z edEdd��Z
dFdGd
d�Z edfdHdd�Z dIdJdd�Z
eefdKd d ��ZedLd d!��Z dFd d"�dMd(d)�Z dFd d*�dNd-d.�ZdOd/d0�ZdPd2d3�ZefdQd4d5�ZdRd9d:�ZdSd<d=�ZdTd?d@�ZdUdAdB�ZdUdCdD�Zd S )V�SignalzKA notification emitter.
:param doc: The docstring for the signal.
ztype[set[t.Any]]� set_class�returnc C �
t dd�S )z�Emitted 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.��doc�r ��self� r �?/opt/hikvison/venv/lib/python3.10/site-packages/blinker/base.py�receiver_connected) s
zSignal.receiver_connectedc C r )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 r r r �receiver_disconnected4 s
z Signal.receiver_disconnectedNr �
str | None�Nonec C s: |r|| _ i | _ d| _t| j�| _t| j�| _i | _d S )NF)�__doc__� receivers�is_mutedr r � _by_receiver�
_by_sender�
_weak_senders)r r r r r �__init__I s �
zSignal.__init__T�receiverr �sender�t.Any�weak�boolc C s� t |�}|tu r
tnt |�}|r t|| �|��| j|< n|| j|< | j| �|� | j| �|� |turQ|| j vrQz
t|| �
|��| j |< W n t yP Y nw d| j v rv| j
jrvz
| j
j| |||d� W |S t yu | �||� � w |S )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 )r$ r% r' )r r
�ANY_IDr �_make_cleanup_receiverr r! �addr r" �_make_cleanup_sender� TypeError�__dict__r �send�
disconnect)r r$ r% r' � receiver_id� sender_idr r r �connect[ s8
�
� �� � �zSignal.connectF�c.Callable[[F], F]c s d� ��fdd� }|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
�fnr r c s � � | ��� | S �N)r3 )r5 �r r% r' r r � decorator� s z%Signal.connect_via.<locals>.decoratorN)r5 r r r r )r r% r' r8 r r7 r � connect_via� s zSignal.connect_via�c.Callable[..., t.Any]� c.Generator[None, None, None]c c s6 � | j ||dd� z dV W | �|� dS | �|� w )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)r3 r0 )r r$ r% r r r � connected_to� s
�zSignal.connected_toc c s$ � d| _ z dV W d| _ dS d| _ w )z�A 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 r r r �muted� s
�z Signal.muted)�_async_wrapper� t.Any | Noner> �^c.Callable[[c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]], c.Callable[..., t.Any]] | None�kwargs�*list[tuple[c.Callable[..., t.Any], t.Any]]c K sn | j rg S g }| �|�D ](}t|�r%|du rtd��||�|fi |��}n||fi |��}|�||f� q |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.
Nz$Cannot send to a coroutine function.�r �
receivers_forr � RuntimeError�append)r r% r> rA �resultsr$ �resultr r r r/ � s !z Signal.send)�
_sync_wrapperrI �^c.Callable[[c.Callable[..., t.Any]], c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]] | Nonec � s| �| j rg S g }| �|�D ].}t|�s)|du rtd��||�|fi |��I dH }n ||fi |��I dH }|�||f� q
|S )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.rC )r r% rI rA rG r$ rH r r r �
send_async� s � zSignal.send_asyncc C s2 | j sdS | jt r dS |tu rdS t|�| jv 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% r r r �has_receivers_for1 s
zSignal.has_receivers_for�/c.Generator[c.Callable[..., t.Any], None, None]c c s� � | j sdS t|�}|| jv r| jt | j| B }n| jt �� }|D ](}| j �|�}|du r0q#t|tj�rH|� }|du rD| � |t� q#|V q#|V q#dS )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) �copy�get�
isinstance�weakref�ref� _disconnect)r r% r2 �idsr1 r$ �strongr r r rD F s& �
�zSignal.receivers_forc C sZ |t u rt}nt|�}t|�}| �||� d| jv r)| jjr+| jj| ||d� dS dS dS )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 rS r. r r r/ )r r$ r% r2 r1 r r r r0 l s
��zSignal.disconnectr1 �
c.Hashabler2 c C sj |t kr#| j�|d �d ur| j�� D ]}|�|� q| j�|d � d S | j| �|� | j| �|� d S r6 )r) r �popr! �values�discardr )r r1 r2 �bucketr r r rS � s zSignal._disconnect�7c.Callable[[weakref.ref[c.Callable[..., t.Any]]], None]c s d� �fdd� }|S ) ztCreate a callback function to disconnect a weakly referenced
receiver when it is garbage collected.
rR �#weakref.ref[c.Callable[..., t.Any]]r r c s t �� s ��� t� d S d S r6 )�sys�
is_finalizingrS r) )rR �r1 r r r �cleanup� s �z.Signal._make_cleanup_receiver.<locals>.cleanupN)rR r\ r r r )r r1 r` r r_ r r* � s z Signal._make_cleanup_receiver�&c.Callable[[weakref.ref[t.Any]], None]c s �t ksJ �d� �fdd� }|S ) z�Create a callback function to disconnect all receivers for a weakly
referenced sender when it is garbage collected.
rR �weakref.ref[t.Any]r r c s6 � j ��d � � j��d�D ]
}� j| ��� qd S )Nr )r" rW r! r rY )rR r1 �r r2 r r r` � s �z,Signal._make_cleanup_sender.<locals>.cleanupN)rR rb r r )r) )r r2 r` r rc r r, � s zSignal._make_cleanup_senderc C s< | j | jfD ]}t|�� �D ] \}}|s|�|d� qqdS )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 �list�itemsrW )r �mapping�identrZ r r r �_cleanup_bookkeeping� s ���zSignal._cleanup_bookkeepingc C s, | j �� | j�� | j�� | j�� dS )z7Disconnect all receivers and senders. Useful for tests.N)r" �clearr r! r r r r r � _clear_state� s
zSignal._clear_state)r r r6 )r r r r )r$ r r% r& r' r( r r )F)r% r& r' r( r r4 )r$ r: r% r& r r; )r r; )r% r? r> r@ rA r& r rB )r% r? rI rJ rA r& r rB )r% r& r r( )r% r& r rM )r$ r: r% r& r r )r1 rV r2 rV r r )r1 rV r r[ )r2 rV r ra )r r )�__name__�
__module__� __qualname__r r
�setr �__annotations__r r r r# r3 r9 r r< r= r/ rK rL rD r0 rS r* r, rh rj r r r r r sD
2� ��5��
2
&
r c s2 e Zd ZdZd
d� fd d
�
Zd� fd d � Z� ZS )� 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.
N�name�strr r r r c s t � �|� || _d S r6 )�superr# rq �r rq r �� __class__r r r# � s
zNamedSignal.__init__c s$ t � �� }|d d� � d| j�d�S )N���z; �>)rs �__repr__rq )r �baseru r r ry � s
zNamedSignal.__repr__r6 )rq rr r r r r )r rr )rk rl rm r r# ry �
__classcell__r r ru r rp � s rp c @ s e Zd ZdZd d d d
�ZdS )
� Namespacez A dict mapping names to signals.Nrq rr r r r rp c C s || vr t ||�| |< | | S )z�Return 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.
)rp rt r r r �signal� s zNamespace.signalr6 �rq rr r r r rp )rk rl rm r r} r r r r r| � s r| c @ s e Zd Zd
d dd �ZdS ) �_PNamespaceSignalNrq rr r r r rp c C s d S r6 r rt r r r �__call__� s z_PNamespaceSignal.__call__r6 r~ )rk rl rm r� r r r r r � s r �default_namespacer} )%�
__future__r �collections.abc�abc�cr] �typing�trQ � collectionsr �
contextlibr � functoolsr �inspectr �
_utilitiesr r r
�TypeVar�Callable�Anyr r
r) r rp �dictrr r| �Protocolr r� ro r} r r r r �<module> s6 ;