For parsing you would typically pass a list to be used as a stack. The "memory" attribute can be any object that you want to pass along to the action functions. The action function may then access attributes of the FSM such as input_symbol, current_state, or "memory". When an action function is called it is passed a reference to the FSM. You use the set_default_transition() method to set the default transition. The FSM also has one default transition that is not associated with any specific input_symbol or state.
The FSM also has a table of transitions that associate: (current_state) -> (action, next_state) You use the add_transition_any() method to add to this transition table. You use the add_transition() and add_transition_list() methods to add to the transition table. The symbols and states can be any objects. The FSM has a table of transitions that associate: (input_symbol, current_state) -> (action, next_state) Where "action" is a function you define. For a given input symbol the process() method uses these tables to decide what action to call and what the next state will be.
You define an FSM by building tables of transitions. The following describes how the FSM works, but you will probably also need to see the example function to understand how the FSM is used in practice.
So this FSM can be used as a Push-down Automata (PDA) since a PDA is a FSM + memory. In addition to state this FSM also maintains a user defined "memory". I wanted a decorator-based state machine without having to use Django.#!/usr/bin/env python """This module implements a Finite State Machine (FSM).
BUILD FINITE STATE AUTOMATA PYTHON INSTALL
To install a package locally for development, run: flit install Running Tests pytest Inspiration
Set up pre-commit hooks in repo: pre-commit install. $ fsm_draw_state_diagram -class examples.turnstile:Turnstile -initial_state close $ fsm_draw_state_diagram -class examples.turnstile:Turnstile Use the fsm_draw_state_diagram command and point to State Machine workflows can be visualized using aįinite-state-machine generates diagrams using The examples folder contains additional workflows. _init_ () ( source =, target = "open" ) def insert_coin ( self ): pass ( source = "open", target = "close" ) def pass_thru ( self ): pass REPL In : turnstile = Turnstile() In : turnstile.state Out: 'close' In : turnstile.insert_coin() In : turnstile.state Out: 'open' In : turnstile.insert_coin() In : turnstile.state Out: 'open' In : turnstile.pass_thru() In : turnstile.state Out: 'close' In : turnstile.pass_thru() - InvalidStartState Traceback (most recent call last) in -> 1 turnstile.pass_thru() ~/state_machine.py in _wrapper(*args, **kwargs) 32 33 if self.state not in source: -> 34 raise InvalidStartState 35 36 for condition in conditions: InvalidStartState: Where the transition function raises an exception: ( source = "off", target = "on", on_error = "failed" ) def turn_on ( self ): raise ValueError Example from finite_state_machine import StateMachine, transition class Turnstile ( StateMachine ): initial_state = "close" def _init_ ( self ): self. state = "off"Ĭan also specify an on_error parameter to handle situations ( source = "off", target = "on", conditions = ) def turn_on ( self ): # specify side effects def light_is_off ( machine ): return machine. Keyword arguments present in the transition function. States can be of type: string, int, bool, Enum, or IntEnum.Ĭan specify a single sate or a list of states for the source parameter Ĭan only specify a single state as the target target.Īll condition functions need to return True for the transition to occur,Įlse a ConditionsNotMet exception will be raised.Ĭondition functions require the same positional position and With an optional parameter for conditions. The transition decorator can be used to specify valid state transitions Subclass StateMachine and set the state instance variable: from finite_state_machine import StateMachine, transition class LightSwitch ( StateMachine ): def _init_ ( self ): self. Installation pip install finite-state-machine Usage Lightweight, decorator-based Python implementation of a Finite State Machine.
0 kommentar(er)
