Module | dispatcher | Multiple-producer-multiple-consumer signal-dispatching. |
Module | error | Error types for Louie. |
Module | plugin | Common plugins for Louie. |
Module | robustapply | Robust apply mechanism. |
Module | saferef | Refactored 'safe reference from dispatcher.py |
Module | sender | Sender classes. |
Module | signal | Signal class. |
Module | version | Louie version information. |
From the __init__.py module:
Function | connect | Connect ``receiver`` to ``sender`` for ``signal``. |
Function | disconnect | Disconnect ``receiver`` from ``sender`` for ``signal``. |
Function | get_all_receivers | Get list of all receivers from global tables. |
Function | reset | Reset the state of Louie. |
Function | send | Send ``signal`` from ``sender`` to all connected receivers. |
Function | send_exact | Send ``signal`` only to receivers registered for exact message. |
Function | send_minimal | Like ``send``, but does not attach ``signal`` and ``sender`` |
Function | send_robust | Send ``signal`` from ``sender`` to all connected receivers catching |
Function | install_plugin | Undocumented |
Function | remove_plugin | Undocumented |
Class | Plugin | Base class for Louie plugins. |
Class | QtWidgetPlugin | A Plugin for Louie that knows how to handle Qt widgets |
Class | TwistedDispatchPlugin | Plugin for Louie that wraps all receivers in callables |
Class | Anonymous | Singleton used to signal 'anonymous sender'. |
Class | Any | Used to represent either 'any sender'. |
Class | All | Used to represent 'all signals'. |
Class | Signal | Undocumented |
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.safe_ref()`` 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 ``All``, receiver will receive all signals from the indicated sender (which might also be ``All``, but is not necessarily ``All``). 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``/``send_exact`` 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`` 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``.
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.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 ``TypeError`` 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.
Send ``signal`` only to receivers registered for exact message.
``send_exact`` allows for avoiding ``Any``/``Anonymous`` registered handlers, sending only to those receivers explicitly registered for a particular signal on a particular sender.Send ``signal`` from ``sender`` to all connected receivers catching errors - ``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 ``TypeError`` 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 (specifically, any subclass of ``Exception``), the error instance is returned as the result for that receiver.