.. image:: https://travis-ci.org/mriehl/fysom.png?branch=master
   :alt: Travis build status image
   :align: left
   :target: https://travis-ci.org/mriehl/fysom
   
.. image:: https://coveralls.io/repos/mriehl/fysom/badge.png?branch=master
    :target: https://coveralls.io/r/mriehl/fysom?branch=master
    :alt: Coverage status

.. image:: https://pypip.in/v/fysom/badge.png
    :target: https://crate.io/packages/fysom/
    :alt: Latest PyPI version

.. image:: https://pypip.in/d/fysom/badge.png
    :target: https://crate.io/packages/fysom/
    :alt: Number of PyPI downloads



License
=======

MIT licensed. All credits go to Jake Gordon for the `original javascript
implementation <https://github.com/jakesgordon/javascript-state-machine/>`_
and to Mansour Behabadi for the `python
port <https://github.com/oxplot/fysom>`_.

Synopsis
========

This is basically Mansours' implementation with unit tests and a build process added.
It's also on PyPi (``pip install fysom``).
Fysom is built and tested on python 2.6 to 3.3 and PyPy.

Installation
============

From your friendly neighbourhood cheeseshop
-------------------------------------------

::

    pip install fysom

Developer setup
---------------

This module uses the `pybuilder <http://pybuilder.github.com>`_.
::

    sudo pip install pyb_init
    pyb-init github mriehl : fysom

Running the tests
-----------------

::

    pyb verify

Generating and using a setup.py
-------------------------------

::

    pyb
    cd target/dist/fysom-$VERSION
    ./setup.py bdist_rpm #build RPM

Looking at the coverage
-----------------------

::

    pyb
    cat target/reports/coverage

USAGE
=====

Basics
------

::

    from fysom import Fysom

    fsm = Fysom({ 'initial': 'green',
                  'events': [
                      {'name': 'warn', 'src': 'green', 'dst': 'yellow'},
                      {'name': 'panic', 'src': 'yellow', 'dst': 'red'},
                      {'name': 'calm', 'src': 'red', 'dst': 'yellow'},
                      {'name': 'clear', 'src': 'yellow', 'dst': 'green'} ] })

... will create an
object with a method for each event:

-  fsm.warn() - transition from 'green' to 'yellow'
-  fsm.panic() - transition from 'yellow' to 'red'
-  fsm.calm() - transition from 'red' to 'yellow'
-  fsm.clear() - transition from 'yellow' to 'green'

along with the following members:

-  fsm.current - contains the current state
-  fsm.isstate(s) - return True if state s is the current state
-  fsm.can(e) - return True if event e can be fired in the current state
-  fsm.cannot(e) - return True if event s cannot be fired in the current
   state

Initialization
--------------

How the state machine should initialize can depend on your application
requirements, so the library provides a number of simple options.

By default, if you don't specify any initial state, the state machine
will be in the 'none' state and you would need to provide an event to
take it out of this state:
::

    fsm = Fysom({'events': [
                    {'name': 'startup', 'src': 'none',  'dst': 'green'},
                    {'name': 'panic', 'src': 'green', 'dst': 'red'},
                    {'name': 'calm', 'src': 'red', 'dst': 'green'}]})
    print fsm.current # "none"
    fsm.startup()
    print fsm.current # "green"

If you specifiy the name of you initial event (as in all the earlier
examples), then an implicit 'startup' event will be created for you and
fired when the state machine is constructed:
::

    fsm = Fysom({'initial': 'green',
                 'events': [
                     {'name': 'panic', 'src': 'green', 'dst': 'red'},
                     {'name': 'calm', 'src': 'red', 'dst': 'green'}]})
    print fsm.current # "green"

If your object already has a startup method, you can use a different
name for the initial event:
::

    fsm = Fysom({'initial': {'state': 'green', 'event': 'init'},
                 'events': [
                     {'name': 'panic', 'src': 'green', 'dst': 'red'},
                     {'name': 'calm',  'src': 'red', 'dst': 'green'}]})
    print fsm.current # "green"

Finally, if you want to wait to call the initial state transition event
until a later date, you can defer it:
::

    fsm = Fysom({'initial': {'state': 'green', 'event': 'init', 'defer': True},
                 'events': [
                     {'name': 'panic', 'src': 'green', 'dst': 'red'},
                     {'name': 'calm',  'src': 'red',   'dst': 'green'}]})
    print fsm.current # "none"
    fsm.init()
    print fsm.current # "green"

Of course, we have now come full circle, this last example pretty much
functions the same as the first example in this section where you simply
define your own startup event.

So you have a number of choices available to you when initializing your
state machine.

Multiple source and destination states for a single event
---------------------------------------------------------
::

    fsm = Fysom({'initial': 'hungry',
                 'events': [
                     {'name': 'eat', 'src': 'hungry', 'dst': 'satisfied'},
                     {'name': 'eat', 'src': 'satisfied', 'dst': 'full'},
                     {'name': 'eat', 'src': 'full', 'dst': 'sick'},
                     {'name': 'rest', 'src': ['hungry', 'satisfied', 'full', 'sick'], 'dst': 'hungry'}]})

This example will create an object with 2 event methods:

-  fsm.eat()
-  fsm.rest()

The rest event will always transition to the hungry state, while the eat
event will transition to a state that is dependent on the current state.

NOTE the rest event in the above example can also be specified as
multiple events with the same name if you prefer the verbose approach.

Callbacks
---------

4 callbacks are available if your state machine has methods using the
following naming conventions:

-  onbefore\_event\_ - fired before the *event*
-  onleave\_state\_ - fired when leaving the old *state*
-  onenter\_state\_ - fired when entering the new *state*
-  onafter\_event\_ - fired after the *event*

You can affect the event in 2 ways:

-  return False from an onbefore\_event\_ handler to cancel the event.
-  return False from an onleave\_state\_ handler to perform an
   asynchronous state transition (see next section)

For convenience, the 2 most useful callbacks can be shortened:

-  on\_event\_ - convenience shorthand for onafter\_event\_
-  on\_state\_ - convenience shorthand for onenter\_state\_

In addition, a generic onchangestate() calback can be used to call a
single function for all state changes.

All callbacks will be passed one argument 'e' which is an object with
following attributes:

-  fsm Fysom object calling the callback
-  event Event name
-  src Source state
-  dst Destination state
-  (any other keyword arguments you passed into the original event
   method)
-  (any positional argument you passed in the original event method,
   in the 'args' attribute of the event)

Note that when you call an event, only one instance of 'e' argument is
created and passed to all 4 callbacks. This allows you to preserve data
across a state transition by storing it in 'e'. It also allows you to
shoot yourself in the foot if you're not careful.

Callbacks can be specified when the state machine is first created:
::

    def onpanic(e):
        print 'panic! ' + e.msg
    def oncalm(e):
        print 'thanks to ' + e.msg + ' done by ' + e.args[0]
    def ongreen(e):
        print 'green'
    def onyellow(e):
        print 'yellow'
    def onred(e):
        print 'red'
    fsm = Fysom({'initial': 'green',
                 'events': [
                     {'name': 'warn', 'src': 'green', 'dst': 'yellow'},
                     {'name': 'panic', 'src': 'yellow', 'dst': 'red'},
                     {'name': 'panic', 'src': 'green', 'dst': 'red'},
                     {'name': 'calm', 'src': 'red', 'dst': 'yellow'},
                     {'name': 'clear', 'src': 'yellow', 'dst': 'green'}],
                 'callbacks': {
                     'onpanic': onpanic,
                     'oncalm': oncalm,
                     'ongreen': ongreen,
                     'onyellow': onyellow,
                     'onred': onred }})

    fsm.panic(msg='killer bees')
    fsm.calm('bob', msg='sedatives in the honey pots')

Additionally, they can be added and removed from the state machine at any time:
::

    def printstatechange(e):
        print 'event: %s, src: %s, dst: %s' % (e.event, e.src, e.dst)

    del fsm.ongreen
    del fsm.onyellow
    del fsm.onred
    fsm.onchangestate = printstatechange

Asynchronous state transitions
------------------------------

Sometimes, you need to execute some asynchronous code during a state
transition and ensure the new state is not entered until you code has
completed.

A good example of this is when you run a background thread to download
something as result of an event. You only want to transition into the
new state after the download is complete.

You can return False from your onleave\_state\_ handler and the state
machine will be put on hold until you are ready to trigger the
transition using the transition() method.
