pydispatch.dispatcher | index

`Multiple-producer-multiple-consumer signal-dispatching
dispatcher is the core of the PyDispatcher system,
providing the primary API and the core logic for the
system.
Module attributes of note:
Any -- Singleton used to signal either "Any Sender" or
"Any Signal". See documentation of the _Any class.
Anonymous -- Singleton used to signal "Anonymous Sender"
See documentation of the _Anonymous class.
Internal attributes:
WEAKREF_TYPES -- tuple of types/classes which represent
weak references to receivers, and thus must be de-
referenced on retrieval to retrieve the callable
object
connections -- { senderkey (id) : { signal : [receivers...]}}
senders -- { senderkey (id) : weakref(sender) }
used for cleaning up sender references on sender
deletion
sendersBack -- { receiverkey (id) : [senderkey (id)...] }
used for cleaning up receiver references on receiver
deletion, (considerably speeds up the cleanup process
vs. the original code.)`

modules-decor heading-text">
Modules

modules-decor">

pydispatch.errors | pydispatch.robustapply | pydispatch.saferef | weakref

functions-decor heading-text">
Functions

functions-decor">

connect(receiver, signal=_Any, sender=_Any, weak=True)
  Connect receiver to sender for signal
  receiver -- a callable Python object which is to receive
  messages/signals/events. Receivers must be hashable
  objects.
  if weak is True, then receiver must be weak-referencable
  (more precisely saferef.safeRef() must be able to create
  a reference to the receiver).
  Receivers are fairly flexible in their specification,
  as the machinery in the robustApply module takes care
  of most of the details regarding figuring out appropriate
  subsets of the sent arguments to apply to a given
  receiver.
  Note:
  if receiver is itself a weak reference (a callable),
  it will be de-referenced by the system's machinery,
  so *generally* weak references are not suitable as
  receivers, though some use might be found for the
  facility whereby a higher-level library passes in
  pre-weakrefed receiver references.
  signal -- the signal to which the receiver should respond
  if Any, receiver will receive any signal from the
  indicated sender (which might also be Any, but is not
  necessarily Any).
  Otherwise must be a hashable Python object other than
  None (DispatcherError raised on None).
  sender -- the sender to which the receiver should respond
  if Any, receiver will receive the indicated signals
  from any sender.
  if Anonymous, receiver will only receive indicated
  signals from send/sendExact which do not specify a
  sender, or specify Anonymous explicitly as the sender.
  Otherwise can be any python object.
  weak -- whether to use weak references to the receiver
  By default, the module will attempt to use weak
  references to the receiver objects. If this parameter
  is false, then strong references will be used.
  returns None, may raise DispatcherTypeError

disconnect(receiver, signal=_Any, sender=_Any, weak=True)
  Disconnect receiver from sender for signal
  receiver -- the registered receiver to disconnect
  signal -- the registered signal to disconnect
  sender -- the registered sender to disconnect
  weak -- the weakref state to disconnect
  disconnect reverses the process of connect,
  the semantics for the individual elements are
  logically equivalent to a tuple of
  (receiver, signal, sender, weak) used as a key
  to be deleted from the internal routing tables.
  (The actual process is slightly more complex
  but the semantics are basically the same).
  Note:
  Using disconnect is not required to cleanup
  routing when an object is deleted, the framework
  will remove routes for deleted objects
  automatically. It's only necessary to disconnect
  if you want to stop routing to a live object.
  returns None, may raise DispatcherTypeError or
  DispatcherKeyError

getAllReceivers(sender=_Any, signal=_Any)
  Get list of all receivers from global tables
  This gets all receivers which should receive
  the given signal from sender, each receiver should
  be produced only once by the resulting generator

getReceivers(sender=_Any, signal=_Any)
  Get list of receivers from global tables
  This utility function allows you to retrieve the
  raw list of receivers from the connections table
  for the given sender and signal pair.
  Note:
  there is no guarantee that this is the actual list
  stored in the connections table, so the value
  should be treated as a simple iterable/truth value
  rather than, for instance a list to which you
  might append new records.
  Normally you would use liveReceivers( getReceivers( ...))
  to retrieve the actual receiver objects as an iterable
  object.

liveReceivers(receivers)
  Filter sequence of receivers to get resolved, live receivers
  This is a generator which will iterate over
  the passed sequence, checking for weak references
  and resolving them, then returning all live
  receivers.

send(signal=_Any, sender=_Anonymous, *arguments, **named)
  Send signal from sender to all connected receivers.
  signal -- (hashable) signal value, see connect for details
  sender -- the sender of the signal
  if Any, only receivers registered for Any will receive
  the message.
  if Anonymous, only receivers registered to receive
  messages from Anonymous or Any will receive the message
  Otherwise can be any python object (normally one
  registered with a connect if you actually want
  something to occur).
  arguments -- positional arguments which will be passed to
  *all* receivers. Note that this may raise TypeErrors
  if the receivers do not allow the particular arguments.
  Note also that arguments are applied before named
  arguments, so they should be used with care.
  named -- named arguments which will be filtered according
  to the parameters of the receivers to only provide those
  acceptable to the receiver.
  Return a list of tuple pairs [(receiver, response), ... ]
  if any receiver raises an error, the error propagates back
  through send, terminating the dispatch loop, so it is quite
  possible to not have all receivers called if a raises an
  error.

sendExact(signal=_Any, sender=_Anonymous, *arguments, **named)
  Send signal only to those receivers registered for exact message
  sendExact allows for avoiding Any/Anonymous registered
  handlers, sending only to those receivers explicitly
  registered for a particular signal on a particular
  sender.

data-decor heading-text">
Data
data-decor"> |  | Anonymous = _Anonymous Any = _Any WEAKREF_TYPES = (<class 'weakref.ReferenceType'>, <class 'pydispatch.saferef.BoundMethodWeakref'>) connections = {} senders = {} sendersBack = {}