Metadata-Version: 2.1
Name: flexsm
Version: 0.1.0.0
Summary: A flexible state machine for Python
Home-page: https://github.com/dayjaby/flexsm
Author: David Jablonski
Author-email: dayjaby@gmail.com
License: UNKNOWN
Description: **********
        Installing
        **********
        
        .. code-block:: sh
        
         pip install flexsm
        
        You can easily install flexsm with pip:
        
        
        ********************************************
        Importing, creating states and state machine
        ********************************************
        
        Creating states and state machines is pretty straightforward:
        
        .. code-block:: python
        
         from flexsm import *
         
         root = State("root")
         state1 = State("state 1")
         state2 = State("state 2")
         
         sm = StateMachine(root)
        
        *******************************
        Transitions and input variables
        *******************************
        
        Transitions are responsible for getting from one state to another. They usually start in one state and end in another. If the next state is only known at runtime, e.g. if it depends on an input variable "x", then you can override the transition method *getNextState*:
        
        .. code-block:: python
        
         @addTransition(state=root)
         class WaitForSomeValueToBecomeSmall(Transition):
             def getNextState(self, x):
                 if x>15:
                     return state2
                 else:
                     return state1
        
        This piece of code allows us to transition from state *root* to *state 1* if x is smaller than 15, for example by calling:
        
        .. code-block:: python
        
         sm.update("x", 10)
        
        or to *state 2* if x is 15 or bigger.
        
        There is also an input variable *time_in_state*, which contains the amount of time we've been in the current state in seconds. The minimal guaranteed resolution for time_in_state is 0.1 seconds, which can be changed in the StateMachine construction:
        
        .. code-block:: python
        
         sm = StateMachine(root, time_resolution=0.01)
        
        By overriding the *check* method, we can transition if we are in the state 5 seconds or longer:
        
        .. code-block:: python
        
         @addTransition(state=state1, next=state2)
         class WaitAMoment(Transition):
             def check(self, time_in_state, x):
                 return time_in_state > 5
         
             def onTrigger(self, time_in_state, x):
                 print("""We are in this boring
                     state since {:.2f} seconds, 
                     with x being {}""".format(time_in_state, x))
        
        We also override *onTrigger*, which is called when the transition is triggered. Note how the parameters for onTrigger and check are equal. The parameters for all transition methods are name sensitive. So you can't simply use the parameter y instead of x and expect y to be 100 if you run sm.update("x", 100). For the same transition, the parameters for getNextState, check and onTrigger even have to be equal!
        
        Transition.check will only be called if the value of one of its parameters changed. Thus, if your code in the check method takes a lot of time, try to avoid frequently changing parameters like time_in_state.
        
        *************
        Parent states
        *************
        
        Consider the following example:
        
        .. code-block:: python
        
         airbourne = State("Airbourne")
         doing360spin = State("Spin 360", parent=airbourne)
         
         sm = StateMachine(doing360spin)
        
        In this case, we are not only in the state *doing360spin*, but also in the state *airbourne*. Thus, any transitions defined on *airbourne* will be considered as well. For example, an airplane could go into an emergency state if its fuel is getting low. Such emergency transitions would be interesting for all states in the air.
        
        
        
Platform: UNKNOWN
Classifier: Programming Language :: Python
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/x-rst
