parley.helpers

# Module parley.helpers

    parley/helpers.py - helper classes and functions for constructing actors.

## Classes

`class Dispatcher:`

>     Inherit from this class to create an actor that behaves as an RPC server:
>     messages received get translated into function calls,
>     and function return values (as well as exceptions) are translated
>     into reply messages.

>     If you override the __init__ function, call the parent __init__
>     last to start the actor.

> `def _default(self, msg, sender, args, kwargs):`

> >     This method is called if the name of a received message
> >     does not correspond to a method.

> `def _dispatch(self, msg, sender, args, kwargs):`

> `def _loop(self):`

> `def _post_dispatch(self, msg, sender, args, kwargs):`

> >     This method is called after a message is dispatched to the
> >     appropriate method.

> `def _pre_dispatch(self, msg, sender, args, kwargs):`

> >     This method is called between when a message has been
> >     received and when it is dispatched to the appropriate method.

> `def filter(self, (msg, sender, args, kwargs)):`

> >     This function is passed to self.recv in the dispatcher main
> >     loop. Override it to define what messages will be received by
> >     this actor.

> `def quit(self, sender):`

> >     By default, Dispatcher objects respond to quit messages
> >     (presumably from linked actors) by raising StopActor.

`class DoNotReply(exceptions.Exception):`

>     Actors incorporating the parley.helpers classes can
>     raise this exception to indicate that no response to the
>     calling actor should be sent.

`class StateMachine:`

>     Behaves like Dispatcher, but self.state (along with an underscore)
>     is prepended to message names before they are looked up.

> `def _default(self, msg, sender, args, kwargs):`

> >     Default handler, called if (state)__default does not exist

> `def _dispatch(self, msg, sender, args, kwargs):`

> `def _loop(self):`

> `def _state_getattr(self, name, default=None):`

## Functions

`def forward_exceptions(lst):`

>     Wraps a function to translate certain exceptions into
>     RemoteExceptions (which will typically be sent as messages
>     to an RPC client).
>     If the list of exceptions is not specified,
>     all exceptions except StopActor are caught in this manner.

>     Usage:
>     @forward_exceptions([KeyError, ValueError])
>     def foo(): ...

`def function_actor(fn, loop=True):`

>     Wraps a function to act as an RPC server.

>     The resulting actor will respond to the "quit" message by exiting
>     and to any other message by calling the function and returning its
>     return value as an RPC reply.

>     If the parameter loop is False, the actor accepts one message
>     and then exits; otherwise, the actor serves forever.