Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/blinker/base.py: 30%
165 statements
« prev ^ index » next coverage.py v7.0.1, created at 2022-12-25 06:11 +0000
1# -*- coding: utf-8; fill-column: 76 -*-
2"""Signals and events.
4A small implementation of signals, inspired by a snippet of Django signal
5API client code seen in a blog post. Signals are first-class objects and
6each manages its own receivers and message emission.
8The :func:`signal` function provides singleton behavior for named signals.
10"""
11from contextlib import contextmanager
12from warnings import warn
13from weakref import WeakValueDictionary
15from blinker._utilities import (
16 WeakTypes,
17 defaultdict,
18 hashable_identity,
19 lazy_property,
20 reference,
21 symbol,
22 )
25ANY = symbol('ANY')
26ANY.__doc__ = 'Token for "any sender".'
27ANY_ID = 0
30class Signal(object):
31 """A notification emitter."""
33 #: An :obj:`ANY` convenience synonym, allows ``Signal.ANY``
34 #: without an additional import.
35 ANY = ANY
37 @lazy_property
38 def receiver_connected(self):
39 """Emitted after each :meth:`connect`.
41 The signal sender is the signal instance, and the :meth:`connect`
42 arguments are passed through: *receiver*, *sender*, and *weak*.
44 .. versionadded:: 1.2
46 """
47 return Signal(doc="Emitted after a receiver connects.")
49 @lazy_property
50 def receiver_disconnected(self):
51 """Emitted after :meth:`disconnect`.
53 The sender is the signal instance, and the :meth:`disconnect` arguments
54 are passed through: *receiver* and *sender*.
56 Note, this signal is emitted **only** when :meth:`disconnect` is
57 called explicitly.
59 The disconnect signal can not be emitted by an automatic disconnect
60 (due to a weakly referenced receiver or sender going out of scope),
61 as the receiver and/or sender instances are no longer available for
62 use at the time this signal would be emitted.
64 An alternative approach is available by subscribing to
65 :attr:`receiver_connected` and setting up a custom weakref cleanup
66 callback on weak receivers and senders.
68 .. versionadded:: 1.2
70 """
71 return Signal(doc="Emitted after a receiver disconnects.")
73 def __init__(self, doc=None):
74 """
75 :param doc: optional. If provided, will be assigned to the signal's
76 __doc__ attribute.
78 """
79 if doc:
80 self.__doc__ = doc
81 #: A mapping of connected receivers.
82 #:
83 #: The values of this mapping are not meaningful outside of the
84 #: internal :class:`Signal` implementation, however the boolean value
85 #: of the mapping is useful as an extremely efficient check to see if
86 #: any receivers are connected to the signal.
87 self.receivers = {}
88 self._by_receiver = defaultdict(set)
89 self._by_sender = defaultdict(set)
90 self._weak_senders = {}
92 def connect(self, receiver, sender=ANY, weak=True):
93 """Connect *receiver* to signal events sent by *sender*.
95 :param receiver: A callable. Will be invoked by :meth:`send` with
96 `sender=` as a single positional argument and any ``kwargs`` that
97 were provided to a call to :meth:`send`.
99 :param sender: Any object or :obj:`ANY`, defaults to ``ANY``.
100 Restricts notifications delivered to *receiver* to only those
101 :meth:`send` emissions sent by *sender*. If ``ANY``, the receiver
102 will always be notified. A *receiver* may be connected to
103 multiple *sender* values on the same Signal through multiple calls
104 to :meth:`connect`.
106 :param weak: If true, the Signal will hold a weakref to *receiver*
107 and automatically disconnect when *receiver* goes out of scope or
108 is garbage collected. Defaults to True.
110 """
111 receiver_id = hashable_identity(receiver)
112 if weak:
113 receiver_ref = reference(receiver, self._cleanup_receiver)
114 receiver_ref.receiver_id = receiver_id
115 else:
116 receiver_ref = receiver
117 if sender is ANY:
118 sender_id = ANY_ID
119 else:
120 sender_id = hashable_identity(sender)
122 self.receivers.setdefault(receiver_id, receiver_ref)
123 self._by_sender[sender_id].add(receiver_id)
124 self._by_receiver[receiver_id].add(sender_id)
125 del receiver_ref
127 if sender is not ANY and sender_id not in self._weak_senders:
128 # wire together a cleanup for weakref-able senders
129 try:
130 sender_ref = reference(sender, self._cleanup_sender)
131 sender_ref.sender_id = sender_id
132 except TypeError:
133 pass
134 else:
135 self._weak_senders.setdefault(sender_id, sender_ref)
136 del sender_ref
138 # broadcast this connection. if receivers raise, disconnect.
139 if ('receiver_connected' in self.__dict__ and
140 self.receiver_connected.receivers):
141 try:
142 self.receiver_connected.send(self,
143 receiver=receiver,
144 sender=sender,
145 weak=weak)
146 except:
147 self.disconnect(receiver, sender)
148 raise
149 if receiver_connected.receivers and self is not receiver_connected:
150 try:
151 receiver_connected.send(self,
152 receiver_arg=receiver,
153 sender_arg=sender,
154 weak_arg=weak)
155 except:
156 self.disconnect(receiver, sender)
157 raise
158 return receiver
160 def connect_via(self, sender, weak=False):
161 """Connect the decorated function as a receiver for *sender*.
163 :param sender: Any object or :obj:`ANY`. The decorated function
164 will only receive :meth:`send` emissions sent by *sender*. If
165 ``ANY``, the receiver will always be notified. A function may be
166 decorated multiple times with differing *sender* values.
168 :param weak: If true, the Signal will hold a weakref to the
169 decorated function and automatically disconnect when *receiver*
170 goes out of scope or is garbage collected. Unlike
171 :meth:`connect`, this defaults to False.
173 The decorated function will be invoked by :meth:`send` with
174 `sender=` as a single positional argument and any ``kwargs`` that
175 were provided to the call to :meth:`send`.
178 .. versionadded:: 1.1
180 """
181 def decorator(fn):
182 self.connect(fn, sender, weak)
183 return fn
184 return decorator
186 @contextmanager
187 def connected_to(self, receiver, sender=ANY):
188 """Execute a block with the signal temporarily connected to *receiver*.
190 :param receiver: a receiver callable
191 :param sender: optional, a sender to filter on
193 This is a context manager for use in the ``with`` statement. It can
194 be useful in unit tests. *receiver* is connected to the signal for
195 the duration of the ``with`` block, and will be disconnected
196 automatically when exiting the block:
198 .. code-block:: python
200 with on_ready.connected_to(receiver):
201 # do stuff
202 on_ready.send(123)
204 .. versionadded:: 1.1
206 """
207 self.connect(receiver, sender=sender, weak=False)
208 try:
209 yield None
210 except:
211 self.disconnect(receiver)
212 raise
213 else:
214 self.disconnect(receiver)
216 def temporarily_connected_to(self, receiver, sender=ANY):
217 """An alias for :meth:`connected_to`.
219 :param receiver: a receiver callable
220 :param sender: optional, a sender to filter on
222 .. versionadded:: 0.9
224 .. versionchanged:: 1.1
225 Renamed to :meth:`connected_to`. ``temporarily_connected_to`` was
226 deprecated in 1.2 and will be removed in a subsequent version.
228 """
229 warn("temporarily_connected_to is deprecated; "
230 "use connected_to instead.",
231 DeprecationWarning)
232 return self.connected_to(receiver, sender)
234 def send(self, *sender, **kwargs):
235 """Emit this signal on behalf of *sender*, passing on ``kwargs``.
237 Returns a list of 2-tuples, pairing receivers with their return
238 value. The ordering of receiver notification is undefined.
240 :param sender: Any object or ``None``. If omitted, synonymous
241 with ``None``. Only accepts one positional argument.
243 :param kwargs: Data to be sent to receivers.
244 """
245 if not self.receivers:
246 # Ensure correct signature even on no-op sends, disable with -O
247 # for lowest possible cost.
248 if __debug__ and sender and len(sender) > 1:
249 raise TypeError('send() accepts only one positional '
250 'argument, %s given' % len(sender))
251 return []
253 # Using '*sender' rather than 'sender=None' allows 'sender' to be
254 # used as a keyword argument- i.e. it's an invisible name in the
255 # function signature.
256 if len(sender) == 0:
257 sender = None
258 elif len(sender) > 1:
259 raise TypeError('send() accepts only one positional argument, '
260 '%s given' % len(sender))
261 else:
262 sender = sender[0]
263 return [(receiver, receiver(sender, **kwargs))
264 for receiver in self.receivers_for(sender)]
266 def has_receivers_for(self, sender):
267 """True if there is probably a receiver for *sender*.
269 Performs an optimistic check only. Does not guarantee that all
270 weakly referenced receivers are still alive. See
271 :meth:`receivers_for` for a stronger search.
273 """
274 if not self.receivers:
275 return False
276 if self._by_sender[ANY_ID]:
277 return True
278 if sender is ANY:
279 return False
280 return hashable_identity(sender) in self._by_sender
282 def receivers_for(self, sender):
283 """Iterate all live receivers listening for *sender*."""
284 # TODO: test receivers_for(ANY)
285 if self.receivers:
286 sender_id = hashable_identity(sender)
287 if sender_id in self._by_sender:
288 ids = (self._by_sender[ANY_ID] |
289 self._by_sender[sender_id])
290 else:
291 ids = self._by_sender[ANY_ID].copy()
292 for receiver_id in ids:
293 receiver = self.receivers.get(receiver_id)
294 if receiver is None:
295 continue
296 if isinstance(receiver, WeakTypes):
297 strong = receiver()
298 if strong is None:
299 self._disconnect(receiver_id, ANY_ID)
300 continue
301 receiver = strong
302 yield receiver
304 def disconnect(self, receiver, sender=ANY):
305 """Disconnect *receiver* from this signal's events.
307 :param receiver: a previously :meth:`connected<connect>` callable
309 :param sender: a specific sender to disconnect from, or :obj:`ANY`
310 to disconnect from all senders. Defaults to ``ANY``.
312 """
313 if sender is ANY:
314 sender_id = ANY_ID
315 else:
316 sender_id = hashable_identity(sender)
317 receiver_id = hashable_identity(receiver)
318 self._disconnect(receiver_id, sender_id)
320 if ('receiver_disconnected' in self.__dict__ and
321 self.receiver_disconnected.receivers):
322 self.receiver_disconnected.send(self,
323 receiver=receiver,
324 sender=sender)
326 def _disconnect(self, receiver_id, sender_id):
327 if sender_id == ANY_ID:
328 if self._by_receiver.pop(receiver_id, False):
329 for bucket in self._by_sender.values():
330 bucket.discard(receiver_id)
331 self.receivers.pop(receiver_id, None)
332 else:
333 self._by_sender[sender_id].discard(receiver_id)
334 self._by_receiver[receiver_id].discard(sender_id)
336 def _cleanup_receiver(self, receiver_ref):
337 """Disconnect a receiver from all senders."""
338 self._disconnect(receiver_ref.receiver_id, ANY_ID)
340 def _cleanup_sender(self, sender_ref):
341 """Disconnect all receivers from a sender."""
342 sender_id = sender_ref.sender_id
343 assert sender_id != ANY_ID
344 self._weak_senders.pop(sender_id, None)
345 for receiver_id in self._by_sender.pop(sender_id, ()):
346 self._by_receiver[receiver_id].discard(sender_id)
348 def _cleanup_bookkeeping(self):
349 """Prune unused sender/receiver bookkeeping. Not threadsafe.
351 Connecting & disconnecting leave behind a small amount of bookkeeping
352 for the receiver and sender values. Typical workloads using Blinker,
353 for example in most web apps, Flask, CLI scripts, etc., are not
354 adversely affected by this bookkeeping.
356 With a long-running Python process performing dynamic signal routing
357 with high volume- e.g. connecting to function closures, "senders" are
358 all unique object instances, and doing all of this over and over- you
359 may see memory usage will grow due to extraneous bookkeeping. (An empty
360 set() for each stale sender/receiver pair.)
362 This method will prune that bookkeeping away, with the caveat that such
363 pruning is not threadsafe. The risk is that cleanup of a fully
364 disconnected receiver/sender pair occurs while another thread is
365 connecting that same pair. If you are in the highly dynamic, unique
366 receiver/sender situation that has lead you to this method, that
367 failure mode is perhaps not a big deal for you.
368 """
369 for mapping in (self._by_sender, self._by_receiver):
370 for _id, bucket in list(mapping.items()):
371 if not bucket:
372 mapping.pop(_id, None)
374 def _clear_state(self):
375 """Throw away all signal state. Useful for unit tests."""
376 self._weak_senders.clear()
377 self.receivers.clear()
378 self._by_sender.clear()
379 self._by_receiver.clear()
382receiver_connected = Signal("""\
383Sent by a :class:`Signal` after a receiver connects.
385:argument: the Signal that was connected to
386:keyword receiver_arg: the connected receiver
387:keyword sender_arg: the sender to connect to
388:keyword weak_arg: true if the connection to receiver_arg is a weak reference
390.. deprecated:: 1.2
392As of 1.2, individual signals have their own private
393:attr:`~Signal.receiver_connected` and
394:attr:`~Signal.receiver_disconnected` signals with a slightly simplified
395call signature. This global signal is planned to be removed in 1.6.
397""")
400class NamedSignal(Signal):
401 """A named generic notification emitter."""
403 def __init__(self, name, doc=None):
404 Signal.__init__(self, doc)
406 #: The name of this signal.
407 self.name = name
409 def __repr__(self):
410 base = Signal.__repr__(self)
411 return "{}; {!r}>".format(base[:-1], self.name)
414class Namespace(dict):
415 """A mapping of signal names to signals."""
417 def signal(self, name, doc=None):
418 """Return the :class:`NamedSignal` *name*, creating it if required.
420 Repeated calls to this function will return the same signal object.
422 """
423 try:
424 return self[name]
425 except KeyError:
426 return self.setdefault(name, NamedSignal(name, doc))
429class WeakNamespace(WeakValueDictionary):
430 """A weak mapping of signal names to signals.
432 Automatically cleans up unused Signals when the last reference goes out
433 of scope. This namespace implementation exists for a measure of legacy
434 compatibility with Blinker <= 1.2, and may be dropped in the future.
436 .. versionadded:: 1.3
438 """
440 def signal(self, name, doc=None):
441 """Return the :class:`NamedSignal` *name*, creating it if required.
443 Repeated calls to this function will return the same signal object.
445 """
446 try:
447 return self[name]
448 except KeyError:
449 return self.setdefault(name, NamedSignal(name, doc))
452signal = Namespace().signal