| Server IP : 85.155.190.233 / Your IP : 216.73.216.103 Web Server : nginx/1.24.0 System : Linux antigravity-cli 6.8.0-31-generic #31-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 20 00:40:06 UTC 2024 x86_64 User : wp-moonbloom ( 1001) PHP Version : 8.3.6 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/blinker/__pycache__/ |
Upload File : |
�
�]ue@P � �$ � d Z ddlmZ ddlZddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlmZ ej. r�ddlZ ej4 dej6 dej8 f �� Z ej4 d� Z ej> d� Z ej6 ej6 e ejB e f gej6 e e f f Z"ej6 ej6 e e f gej6 e ejB e f f Z# ed� Z$de$_ dZ%ejL Z& G d� d� Z' e'd� Z( G d� de'� Z) G d � d e*� Z+ G d � d e� Z, e+� jZ Z-y) 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.)�bound�T�P�ANYzToken for "any sender".c �X � e Zd ZU dZeZeZded< edd�� Z edd�� Z
d d d�Z edf d d �Z d d d
�Z
eef d!d �� Zed"d �� Zef d#d
�Zdd� d$d�Zdd� d%d�Zd&d�Zd'd�Z d(d�Zefd)d�Zd*d�Zd+d�Zd,d�Zd-d�Zd-d�Z y).�SignalzA notification emitter.z type[set]� set_classc � � t d�� S )z�Emitted 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.��doc�r ��selfs �./usr/lib/python3/dist-packages/blinker/base.py�receiver_connectedzSignal.receiver_connected8 s � � �>�?�?� c � � t d�� S )a Emitted 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.r r r s r �receiver_disconnectedz Signal.receiver_disconnectedD s � �, �A�B�Br Nc � � |r|| _ i | _ d| _ t | j � | _ t | j � | _ i | _ y)zt
:param doc: optional. If provided, will be assigned to the signal's
__doc__ attribute.
FN)�__doc__� receivers�is_mutedr r � _by_receiver�
_by_sender�
_weak_senders)r r s r �__init__zSignal.__init__\ sY � � � �D�L� PR��� ��
�CN� �N�N�D
��� BM� �N�N�B
��� GI��r Tc � � t |� }|r t || j � }||_ n|}|t u rt
}n t |� }| j j ||� | j | j |� | j | j |� ~|t urI|| j vr; t || j � }||_
| 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% ||� |�d}~ww xY w# t $ r}| j% ||� |�d}~ww xY w)aa Connect *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 )�receiver�sender�weakN)� receiver_arg�
sender_arg�weak_arg)r
r
�_cleanup_receiver� receiver_idr �ANY_IDr% �
setdefaultr( �addr' r) �_cleanup_sender� sender_id� TypeError�__dict__r �send�
disconnect) r r, r- r. r3 � receiver_refr8 �
sender_ref�es r �connectzSignal.connectt s� � �* (��1� � �$�X�t�/E�/E�F�L�'2�L� $�#�L� �S�=� �I�)�&�1�I� ���!�!�+�|�<� ��� �"�&�&�{�3� ���+�&�*�*�9�5� � �� ��$�2D�2D�!D�
� &�v�t�/C�/C� D�
�'0�
�$� �"�"�-�-�i��D� � �4�=�=� 0�T�5L�5L�5V�5V�
��'�'�,�,��8�F�� -� � � '� '�D�8J�,J�
�"�'�'��x�F�T� (� � ��x���/ �
��
�� �
�����&�1����
�� �
�����&�1����
�sB �8 E, � E; �F �, E8�7E8�; F �F�F � G�)F=�=Gc � � ��� d� ��fd� }|S )aK Connect 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 �. �� �j | ��� | S �N)r@ )�fnr r- r. s ���r � decoratorz%Signal.connect_via.<locals>.decorator� s �� � �L�L��V�T� *��Ir )rD r �returnr � )r r- r. rE s ``` r � connect_viazSignal.connect_via� s �� �0 � �r c # � K � | j ||d�� d�� | j |� y# | j |� w xY w�w)ah Execute 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)r- r. N)r@ r< �r r, r- s r � connected_tozSignal.connected_to� s< � �� �.
� � �X�f�5� �9� &��J� �O�O�H� %��D�O�O�H� %�s �A�. �A�A�Ac # �r K � d| _ d�� d| _ y# t $ r}|�d}~ww xY w# d| _ w xY w�w)z\Context manager for temporarily disabling signal.
Useful for test purposes.
TNF)r& � Exception)r r? s r �mutedz Signal.muted� sB � �� �
��
� "��J� "�D�M�� � ��G�� �� "�D�M�s$ �7� �7� (�#�(�+ � 4�7c �F � t dt � | j ||� S )ag 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.)r �DeprecationWarningrK rJ s r �temporarily_connected_toz Signal.temporarily_connected_to s' � �
� O� �
� � � ��6�2�2r )�_async_wrapperc �� � | j rg S | j |� }g }| j |� D ]> }t |� r|� t d� � ||� } ||fi |��}|j ||f� �@ |S )a Emit 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 function�r& �_extract_sender�
receivers_forr � RuntimeError�append)r rR r- �kwargs�resultsr, �results r r; z Signal.send s� � �$ �=�=��I��%�%�f�-���� �*�*�6�2� /�H�"�8�,�!�)�&�'L�M�M�)�(�3�� �f�/��/�F� �N�N�H�f�-� .�
/� �r )�
_sync_wrapperc � � K � | j rg S | j |� }g }| j |� D ]F }t |� s|� t d� � ||� } ||fi |��� d{ ��� }|j ||f� �H |S 7 ��w)a Emit 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 functionrT )r r\ r- rY rZ r, r[ s r �
send_asynczSignal.send_async7 s� � �� �$ �=�=��I��%�%�f�-���� �*�*�6�2� /�H�&�x�0� �(�&�'P�Q�Q�(��2��#�F�5�f�5�5�F� �N�N�H�f�-� .�
/� �� 6�s �A"B�$B �% Bc �� � | j s*|r&t |� dkD rt dt |� � d�� �g S t |� dk( rd }|S t |� dkD rt dt |� � d�� �|d }|S )N� z-send() accepts only one positional argument, z givenr )r% �lenr9 �r r- s r rU zSignal._extract_senderW s� � ��~�~� $��F� �a�� �C�C��K�=�PV�W�� � �I�
�v�;�!� ��F� �
�
��[�1�_��?��F� �}�F�S��
� �A�Y�F��
r c � � | j sy| j t ry|t u ryt |� | j v S )z�True 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( r4 r r
rb s r �has_receivers_forzSignal.has_receivers_forn s; � � �~�~�� �?�?�6� "�� �S�=�� ��(�D�O�O�;�;r c # � K � | j r�t |� }|| j v r$| j t | j | z }n!| j t j � }|D ]V }| j j |� }|��!t
|t � r" |� }|�| j |t � �Q|}|�� �X yy�w)z2Iterate all live receivers listening for *sender*.N) r% r
r( r4 �copy�get�
isinstancer � _disconnect)r r- r8 �idsr3 r, �strongs r rV zSignal.receivers_for~ s� � �� �
�>�>�)�&�1�I��D�O�O�+��o�o�f�-���� �0J�J���o�o�f�-�2�2�4�� "�
� � �>�>�-�-�k�:���#� � �h� �2� %�Z�F� �~� �(�(��f�=� � %�H� ��
�
�s �CC
c � � |t u rt }n t |� }t |� }| j ||� d| j v r6| j
j r | j
j | ||�� yyy)a Disconnect *receiver* from this signal's events.
:param receiver: a previously :meth:`connected<connect>` callable
:param sender: a specific sender to disconnect from, or :obj:`ANY`
to disconnect from all senders. Defaults to ``ANY``.
r" )r, r- N)r r4 r
ri r: r" r% r; )r r, r- r8 r3 s r r< zSignal.disconnect� sv � � �S�=� �I�)�&�1�I�'��1� � ����i�0�
$�t�}�}� 4��*�*�4�4� � &� &� +� +�D�8�F� +� S� 5�
5r c �` � |t k( ri| j j |d� r0| j j � D ] }|j |� � | j j |d � y | j | j |� | j | j |� y )NF)r4 r' �popr( �values�discardr% )r r3 r8 �buckets r ri zSignal._disconnect� s� � � �� �� � �$�$�[�%�8� "�o�o� 4� 4� 6� 0�F��N�N�;�/�0� �N�N� � �{�D� 1� �O�O�I� &� .� .�{� ;� � � �k� *� 2� 2�9� =r c �` � | j t t |j � t � y)z'Disconnect a receiver from all senders.N)ri �castr r3 r4 )r r= s r r2 zSignal._cleanup_receiver� s � � ����l�L�,D�,D�E�v�Nr c � � t t |j � }|t k7 sJ �| j j |d� | j j |d� D ] }| j | j |� �" y)z'Disconnect all receivers from a sender.NrG ) rs r r8 r4 r) rn r( r' rp )r r> r8 r3 s r r7 zSignal._cleanup_sender� sq � �� �z�';�';�<� ��F�"�"�"� ��� � �y�$�/� �?�?�.�.�y�"�=� >�K� � � �k� *� 2� 2�9� =� >r c � � | j | j fD ]8 }t |j � � D ] \ }}|r� |j |d� � �: y)ar Prune 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' �list�itemsrn )r �mapping�_idrq s r �_cleanup_bookkeepingzSignal._cleanup_bookkeeping� sQ � �* ����):�):�;� +�G� #�G�M�M�O� 4�
+� ��V� ��K�K��T�*�
+� +r c �� � | j j � | j j � | j j � | j j � y)z4Throw away all signal state. Useful for unit tests.N)r) �clearr% r( r' r s r � _clear_statezSignal._clear_state� sF � � ��� � �"� ��� � � � ��� � � � ��� � �!r )rF r rC )r �
str | NonerF �None)r, r r- �t.Anyr. �boolrF r )F)r- r� r. r� rF z$t.Callable[[T_callable], T_callable])r, �
t.Callabler- r� rF � t.Generator[None, None, None])rF r� )r, r� r- r� rF zt.ContextManager[None])r- r� rR zAsyncWrapperType | NonerY r� rF � list[tuple[t.Callable, t.Any]])r- r� r\ zSyncWrapperType | NonerY r� rF r� )r- r� rF r� )r- r� rF r� )r- r� rF z3t.Generator[t.Callable[[t.Any], t.Any], None, None])r, r� r- r� rF r )r3 r r8 r rF r )r= r rF r )r> r rF r )rF r ) �__name__�
__module__� __qualname__r$ r �setr �__annotations__r r r" r* r@ rH r rK rN rQ r; r^ rU rd rV r< ri r2 r7 rz r} rG r r r r / s� � �!� �C� �I�y� �� @� � @� �C� �C�.I�2 58�d�D�"�D�,1�D�?C�D� �D�N +0� �� �#'� � -� �< �47�&�"�&�,1�&� &�&� �&�8 �
"� �
"� 58�3�"�3�,1�3� �3�0 37� �� � 0� � � �
(� �F 15� �� � .� � � �
(� �@�.<� �� � <� �. @C� T�.>�O�>�+�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
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.
c �" � e Zd ZdZddd�Zdd�Zy)� NamedSignalz%A named generic notification emitter.Nc �> � t j | |� || _ y rC )r r* �name)r r� r s r r* zNamedSignal.__init__� s � �����c�"� �� r c �V � t j | � }|d d � d| j �d�S )N���z; �>)r �__repr__r� )r �bases r r� zNamedSignal.__repr__ s- � ����t�$���s��)��B�t�y�y�m�1�-�-r rC )r� �strr r~ rF r )rF r� )r� r� r� r$ r* r� rG r r r� r� � s � �/�� .r r� c � � e Zd ZdZddd�Zy)� Namespacez%A mapping of signal names to signals.Nc �h � | | S # t $ r! | j |t ||� � }|cY S w xY w�z�Return the :class:`NamedSignal` *name*, creating it if required.
Repeated calls to this function will return the same signal object.
��KeyErrorr5 r� �r r� r r[ s r �signalzNamespace.signal �< � � ���:� ��� ��_�_�T�;�t�S�+A�B�F��M� �� � �'1�1rC �r� r� r r~ rF r� �r� r� r� r$ r� rG r r r� r� s
� �/�
r r� c � � e Zd ZdZddd�Zy)�
WeakNamespacea- A 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
Nc �h � | | S # t $ r! | j |t ||� � }|cY S w xY wr� r� r� s r r� zWeakNamespace.signal! r� r� rC r� r� rG r r r� r� s � ��
r r� ).r$ �
__future__r �typing�t� collectionsr �
contextlibr �inspectr �warningsr �weakrefr �blinker._utilitiesr r
r r r
r r �
TYPE_CHECKING�typing_extensions�te�TypeVar�Callable�Anyr r � ParamSpecr � Awaitable�AsyncWrapperType�SyncWrapperTyper r4 rs r r r� �dictr� r� r� rG r r �<module>r� si ��� #� � #� %� '� � '� 2� 0� +� ,� (� %� (��?�?�"�����<�q�z�z�#�q�u�u�*�/E�F�J��� � �#��A��� � �S��A��z�z�1�:�:�a����Q� �.?�#@�"A�1�:�:�a�QR�d�CS�"S�T���j�j�!�*�*�Q��T�"2�!3�Q�Z�Z��1�;�;�q�>�@Q�5R�!R�S�O� �U�m��'�� �
�� �v�v��r"� r"�j
��� �( .�&� .�
��
� �'� �0
�� � �r