Package v.c.louie

Part of vmc.contrib

No package docstring
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
def connect(receiver, signal=All, 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.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``.
def disconnect(receiver, signal=All, 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``.
def get_all_receivers(sender=Any, signal=All):

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.
def reset():

Reset the state of Louie.

Useful during unit testing. Should be avoided otherwise.
def send(*arguments, signal=All, sender=Anonymous, **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 ``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.
def send_exact(*arguments, signal=All, sender=Anonymous, **named):

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.
def send_minimal(*arguments, signal=All, sender=Anonymous, **named):
Like ``send``, but does not attach ``signal`` and ``sender`` arguments to the call to the receiver.
def send_robust(*arguments, signal=All, sender=Anonymous, **named):
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.
def install_plugin(plugin):
Undocumented
def remove_plugin(plugin):
Undocumented
API Documentation for vodafone-mobile-connect-card-driver-for-linux, generated by pydoctor at 2008-01-10 13:06:31.