pydispatch.dispatcher
index
/home/mcfletch/OpenGL-dev/pydispatcher/pydispatch/dispatcher.py

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
       
pydispatch.errors
pydispatch.robustapply
pydispatch.saferef
weakref

 
Classes
       
object
_Parameter
_Anonymous
_Any

 
class _Anonymous(_Parameter)
    Singleton used to signal "Anonymous Sender"
 
The Anonymous object is used to signal that the sender
of a message is not specified (as distinct from being
"any sender").  Registering callbacks for Anonymous
will only receive messages sent without senders.  Sending
with anonymous will only send messages to those receivers
registered for Any or Anonymous.
 
Note:
    The default sender for connect is Any, while the
    default sender for send is Anonymous.  This has
    the effect that if you do not specify any senders
    in either function then all messages are routed
    as though there was a single sender (Anonymous)
    being used everywhere.
 
 
Method resolution order:
_Anonymous
_Parameter
object

Methods inherited from _Parameter:
__repr__(self)
Return repr(self).

Data descriptors inherited from _Parameter:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class _Any(_Parameter)
    Singleton used to signal either "Any Sender" or "Any Signal"
 
The Any object can be used with connect, disconnect,
send, or sendExact to signal that the parameter given
Any should react to all senders/signals, not just
a particular sender/signal.
 
 
Method resolution order:
_Any
_Parameter
object

Methods inherited from _Parameter:
__repr__(self)
Return repr(self).

Data descriptors inherited from _Parameter:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class _Parameter(object)
    Used to represent default parameter values.
 
  Methods defined here:
__repr__(self)
Return repr(self).

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
_cleanupConnections(senderkey, signal)
Delete any empty signals for senderkey. Delete senderkey if empty.
_killBackref(receiver, senderkey)
Do the actual removal of back reference from receiver to senderkey
_removeBackrefs(senderkey)
Remove all back-references to this senderkey
_removeOldBackRefs(senderkey, signal, receiver, receivers)
Kill old sendersBack references from receiver
 
This guards against multiple registration of the same
receiver for a given signal and sender leaking memory
as old back reference records build up.
 
Also removes old receiver instance from receivers
_removeReceiver(receiver)
Remove receiver from connections.
_removeSender(senderkey)
Remove senderkey from connections.
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 liveReceiversgetReceivers( ...))
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
        Anonymous = _Anonymous
Any = _Any
WEAKREF_TYPES = (<class 'weakref.ReferenceType'>, <class 'pydispatch.saferef.BoundMethodWeakref'>)
__cached__ = '/home/mcfletch/OpenGL-dev/pydispatcher/pydispatch/__pycache__/dispatcher.cpython-310.pyc'
__file__ = '/home/mcfletch/OpenGL-dev/pydispatcher/pydispatch/dispatcher.py'
__loader__ = <_frozen_importlib_external.SourceFileLoader object>
__name__ = 'pydispatch.dispatcher'
__package__ = 'pydispatch'
__spec__ = ModuleSpec(name='pydispatch.dispatcher', loader=...penGL-dev/pydispatcher/pydispatch/dispatcher.py')
connections = {}
senders = {}
sendersBack = {}