exploring python transitions

foo.py

#!/usr/bin/env python

# exploring all the callbacks

from transitions import Machine, State, Transition

class Matter(Machine):
    def __init__(self, *args, **kwargs):
        Machine.__init__(
                self,
                states=['A', 'B', 'C'],
                initial='A',
                prepare_event=['on_prepare_event'],
                before_state_change=['on_before_state_change'],
                after_state_change=['on_after_state_change'],
                finalize_event=['on_finalize_event'],
                send_event=True
        )
        self.add_transition(
                trigger='step',
                source='A',
                dest='B',
                prepare=['on_prepare'],
                conditions=['on_condition'],
                unless=['on_unless'],
                before=['on_before'],
                after=['on_after'],
        )
        self.add_transition(
                trigger='step',
                source='B',
                dest='C',
                prepare=['on_prepare'],
                conditions=['on_condition'],
                unless=['on_unless'],
                before=['on_before'],
                after=['on_after'],
        )

    def on_prepare_event(self, event):
        print('M.prepare_event')

    def on_before_state_change(self, event):
        print('M.before_state_change')

    def on_after_state_change(self, event):
        print('M.after_state_change')

    def on_finalize_event(self, event):
        print('M.finalize_event')

    def on_prepare(self, event):
        print('T.prepare')
        fn = 'on_prepare_{}_to_{}'.format(
                event.transition.source,
                event.transition.dest
        )
        if hasattr(self.__class__, fn):
            getattr(self.__class__, fn)(self, event)

    def on_prepare_A_to_B(self, event):
        print('T.prepare A to B')

    def on_prepare_B_to_C(self, event):
        print('T.prepare B to C')

    def on_condition(self, event):
        print('T.condition')
        fn = 'on_condition_{}_to_{}'.format(
                event.transition.source,
                event.transition.dest
        )
        if hasattr(self.__class__, fn):
            return getattr(self.__class__, fn)(self, event)
        else:
            return True

    def on_condition_A_to_B(self, event):
        print('T.condition A to B')
        return True

    def on_condition_B_to_C(self, event):
        print('T.condition B to C')
        return False

    def on_unless(self, event):
        print('T.unless')
        return False

    def on_before(self, event):
        print('T.before')

    def on_after(self, event):
        print('T.after')

    def on_exit_A(self, event):
        print('S.on_exit A')
        fn = 'on_exit_{}_to_{}'.format(
                event.transition.source,
                event.transition.dest
        )
        if hasattr(self.__class__, fn):
            getattr(self.__class__, fn)(self, event)

    def on_exit_A_to_B(self, event):
        print('S.on_exit A to B')

    def on_enter_B(self, event):
        print('S.on_enter B')
        fn = 'on_enter_{}_from_{}'.format(
                event.transition.dest,
                event.transition.source
        )
        if hasattr(self.__class__, fn):
            getattr(self.__class__, fn)(self, event)

    def on_enter_B_from_A(self, event):
        print('S.on_enter B from A')

    def on_exit_B(self, event):
        print('S.on_exit B')
        fn = 'on_exit_{}_to{}'.format(
                event.transition.source,
                event.transition.dest
        )
        if hasattr(self.__class__, fn):
            getattr(self.__class__, fn)(self, event)

    def on_exit_B_to_C(self, event):
        print('S.on_exit B to C')

    def on_enter_C(self, event):
        print('S.on_enter C')
        fn = 'on_enter_{}_from_{}'.format(
                event.transition.dest,
                event.transition.source
        )
        if hasattr(self.__class__, fn):
            getattr(self.__class__, fn)(self, event)

    def on_enter_C_from_B(self, event):
        print('S.on_enter C from B')

if __name__ == '__main__':
    matter = Matter()
    print(matter.state)
    matter.step()
    print(matter.state)
    matter.step()
    print(matter.state)