Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(17)  |  Call(0)  |  Derive(0)  |  Import(17)
Creates an Event Handler

This decorator can be applied to methods of classes derived from
:class:`circuits.core.components.BaseComponent`. It marks the method as a
handler for the events passed as arguments to the ``@handler`` decorator.
The events are specified by their name.

The decorated method's arguments must match the arguments passed to the
:class:`circuits.core.events.Event` on creation. Optionally, the
method may have an additional first argument named *event*. If declared,(more...)

        def handler(*names, **kwargs):
    """Creates an Event Handler

    This decorator can be applied to methods of classes derived from
    :class:`circuits.core.components.BaseComponent`. It marks the method as a
    handler for the events passed as arguments to the ``@handler`` decorator.
    The events are specified by their name.

    The decorated method's arguments must match the arguments passed to the
    :class:`circuits.core.events.Event` on creation. Optionally, the
    method may have an additional first argument named *event*. If declared,
    the event object that caused the handler to be invoked is assigned to it.

    By default, the handler is invoked by the component's root
    :class:`~.manager.Manager` for events that are propagated on the channel
    determined by the BaseComponent's *channel* attribute.
    This may be overridden by specifying a different channel as a keyword
    parameter of the decorator (``channel=...``).

    Keyword argument ``priority`` influences the order in which handlers
    for a specific event are invoked. The higher the priority, the earlier
    the handler is executed.

    If you want to override a handler defined in a base class of your
    component, you must specify ``override=True``, else your method becomes
    an additional handler for the event.

    **Return value**

    Normally, the results returned by the handlers for an event are simply
    collected in the :class:`circuits.core.events.Event`'s :attr:`value`
    attribute. As a special case, a handler may return a
    :class:`types.GeneratorType`. This signals to the dispatcher that the
    handler isn't ready to deliver a result yet.
    Rather, it has interrupted it's execution with a ``yield None``
    statement, thus preserving its current execution state.

    The dispatcher saves the returned generator object as a task.
    All tasks are reexamined (i.e. their :meth:`next()` method is invoked)
    when the pending events have been executed.

    This feature avoids an unnecessarily complicated chaining of event
    handlers. Imagine a handler A that needs the results from firing an
    event E in order to complete. Then without this feature, the final
    action of A would be to fire event E, and another handler for
    an event ``SuccessE`` would be required to complete handler A's
    operation, now having the result from invoking E available
    (actually it's even a bit more complicated).

    Using this "suspend" feature, the handler simply fires event E and
    then yields ``None`` until e.g. it finds a result in E's :attr:`value`
    attribute. For the simplest scenario, there even is a utility
    method :meth:`circuits.core.manager.Manager.callEvent` that combines
    firing and waiting.
    """

    def wrapper(f):
        if names and isinstance(names[0], bool) and not names[0]:
            f.handler = False
            return f

        f.handler = True

        f.names = names
        f.priority = kwargs.get("priority", 0)
        f.channel = kwargs.get("channel", None)
        f.override = kwargs.get("override", False)

        args = getargspec(f)[0]

        if args and args[0] == "self":
            del args[0]
        f.event = getattr(f, "event", bool(args and args[0] == "event"))

        return f

    return wrapper
        


src/c/i/circuits-3.0.0.dev/circuits/protocols/http.py   circuits(Download)
 
from io import BytesIO
 
from circuits.core import handler, BaseComponent, Event
 

src/c/i/circuits-3.0.0.dev/circuits/app/daemon.py   circuits(Download)
import errno
 
from circuits.core import handler, BaseComponent, Event
 
 

src/c/i/circuits-3.0.0.dev/circuits/io/serial.py   circuits(Download)
from collections import deque
 
from circuits.core import Component, handler, Event
from circuits.core.pollers import BasePoller, Poller
from circuits.core.utils import findcmp

src/c/i/circuits-3.0.0.dev/circuits/io/file.py   circuits(Download)
from circuits.tools import tryimport
from circuits.core.utils import findcmp
from circuits.core import handler, Component, Event
from circuits.core.pollers import BasePoller, Poller
from circuits.six import binary_type, string_types, PY3

src/c/i/circuits-3.0.0.dev/circuits/protocols/line.py   circuits(Download)
import re
 
from circuits.core import handler, Event, BaseComponent
 
LINESEP = re.compile(b"\r?\n")

src/c/i/circuits-3.0.0.dev/circuits/protocols/irc.py   circuits(Download)
 
from circuits.net.events import write
from circuits.core import handler, Event, Component
 
from .line import Line

src/c/i/circuits-3.0.0.dev/circuits/web/client.py   circuits(Download)
from circuits.net.sockets import TCPClient
from circuits.net.events import close, connect, write
from circuits.core import handler, BaseComponent, Event
 
 

src/c/i/circuits-3.0.0.dev/circuits/web/http.py   circuits(Download)
from circuits.six import text_type
from circuits.net.events import close, write
from circuits.core import handler, BaseComponent, Value
 
from . import wrappers

src/c/i/circuits-3.0.0.dev/circuits/web/servers.py   circuits(Download)
from circuits import io
from circuits.net.sockets import read, write
from circuits.core import handler, BaseComponent
from circuits.net.sockets import TCPServer, UNIXServer
 

src/c/i/circuits-3.0.0.dev/circuits/net/sockets.py   circuits(Download)
from circuits.six import binary_type
from circuits.core.utils import findcmp
from circuits.core import handler, BaseComponent
from circuits.core.pollers import BasePoller, Poller
 

  1 | 2  Next