def test_wrong_nesting(self): correct = ['A', {'name': 'B', 'children': self.stuff.machine}] wrong_type = ['A', {'name': 'B', 'children': self.stuff}] siblings = ['A', {'name': 'B', 'children': ['1', self.stuff.machine]}] collision = ['A', {'name': 'B', 'children': ['A', self.stuff.machine]}] m = Machine(None, states=correct) if State.separator in '_': m.to_B_C_3_a() else: m.to_B.C.s3.a() with self.assertRaises(ValueError): m = Machine(None, states=wrong_type) with self.assertRaises(ValueError): m = Machine(None, states=collision) m = Machine(None, states=siblings) if State.separator in '_': m.to_B_1() m.to_B_A() else: m.to_B.s1() m.to_B.A()
def test_reuse_prepare(self): class Model: def __init__(self): self.prepared = False def preparation(self): self.prepared = True ms_model = Model() ms = Machine(ms_model, states=["C", "D"], transitions={ "trigger": "go", "source": "*", "dest": "D", "prepare": "preparation" }, initial="C") ms_model.go() self.assertTrue(ms_model.prepared) m_model = Model() m = Machine(m_model, states=["A", "B", { "name": "NEST", "children": ms }]) m_model.to('NEST%sC' % State.separator) m_model.go() self.assertTrue(m_model.prepared)
def test_blueprint_remap(self): states = ['1', '2', '3', 'finished'] transitions = [ {'trigger': 'increase', 'source': '1', 'dest': '2'}, {'trigger': 'increase', 'source': '2', 'dest': '3'}, {'trigger': 'decrease', 'source': '3', 'dest': '2'}, {'trigger': 'decrease', 'source': '1', 'dest': '1'}, {'trigger': 'reset', 'source': '*', 'dest': '1'}, {'trigger': 'done', 'source': '3', 'dest': 'finished'} ] counter = Machine(states=states, transitions=transitions, initial='1') new_states = ['A', 'B', {'name': 'C', 'children': [counter, {'name': 'X', 'children': ['will', 'be', 'filtered', 'out']}], 'remap': {'finished': 'A', 'X': 'A'}}] new_transitions = [ {'trigger': 'forward', 'source': 'A', 'dest': 'B'}, {'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator}, {'trigger': 'backward', 'source': 'C', 'dest': 'B'}, {'trigger': 'backward', 'source': 'B', 'dest': 'A'}, {'trigger': 'calc', 'source': '*', 'dest': 'C%s1' % State.separator}, ] walker = Machine(states=new_states, transitions=new_transitions, before_state_change='watch', after_state_change='look_back', initial='A') walker.watch = lambda: 'walk' walker.look_back = lambda: 'look_back' counter.increase() counter.increase() counter.done() self.assertEqual(counter.state, 'finished') with self.assertRaises(MachineError): walker.increase() self.assertEqual(walker.state, 'A') walker.forward() walker.forward() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() self.assertEqual(walker.state, 'C%s2' % State.separator) walker.reset() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.to_A() self.assertEqual(walker.state, 'A') walker.calc() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() walker.increase() walker.done() self.assertEqual(walker.state, 'A') self.assertFalse('C.finished' in walker.states)
def test_wrong_nesting(self): correct = ['A', {'name': 'B', 'children': self.stuff.machine}] wrong_type = ['A', {'name': 'B', 'children': self.stuff}] siblings = ['A', {'name': 'B', 'children': ['1', self.stuff.machine]}] m = Machine(None, states=correct) with self.assertRaises(ValueError): m = Machine(None, states=wrong_type) with self.assertRaises(ValueError): m = Machine(None, states=siblings)
def __init__(self, data_model: MachineDefinition, object_model: typing.Any) -> None: # Model definition self.data_model = data_model # Model metadata self.name = self.data_model.get_model_name() self.description = self.name # Representation of the test product (source of truth) self.object_model = object_model # Instantiate the state machine self.state = None self.machine = Machine( model=self, states=self.data_model.get_list_of_states(), initial=self.data_model.get_initial_state(), send_event=False, ) self.reporter = EventTracker() self.requested_execution_steps = [] # List of PathStep objects self.current_step = None # PathStep object self.trigger_list = [] # List of triggers to execute
def __init__ (self, name): annotator.__init__(self, name) self.machine = Machine(model=self, states=HFSA15._states, initial='waiting') self.machine.add_transition('start_analysis', 'waiting', 'searching_for_first_spondeus_secondF', after='_search_second') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_secondF', 'searching_for_first_spondeus_firstF', unless=[self._found_first], after='_search_first') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_secondF', 'searching_for_second_spondeus_firstF', conditions=[self._found_first], after='_search_first') self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_firstF', 'found_two_spondees', conditions=[self._found_second]) self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_firstF', 'searching_for_second_spondeus_fourthF', unless=[self._found_second], after='_search_fourth') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_firstF', 'searching_for_first_spondeus_fourthF', unless=[self._found_first], after='_search_fourth') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_firstF', 'searching_for_second_spondeus_fourthF', conditions=[self._found_first], after='_search_fourth') self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_fourthF', 'found_two_spondees', conditions=[self._found_second]) self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_fourthF', 'searching_for_second_spondeus_thirdF', unless=[self._found_second], after='_search_third') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_fourthF', 'searching_for_first_spondeus_thirdF', unless=[self._found_first], after='_search_third') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_fourthF', 'searching_for_second_spondeus_thirdF', conditions=[self._found_first], after='_search_third') self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_thirdF', 'found_two_spondees', conditions=[self._found_second]) self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_thirdF', 'searching_for_second_spondeus_fifthF', unless=[self._found_second], after='_search_fifth') self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_thirdF', 'no_spondeus_found', unless=[self._found_first]) self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_thirdF', 'searching_for_second_spondeus_fifthF', conditions=[self._found_first], after='_search_fifth') self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_fifthF', 'found_two_spondees', conditions=[self._found_second]) #deal with implausible spondeus positions self.machine.add_transition('search_spondeus', 'found_two_spondees', 'no_spondeus_found') self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_fifthF', 'no_spondeus_found', unless=[self._found_second]) self.machine.add_transition('not_found', 'no_spondeus_found', 'fallback') self.machine.add_transition('verified', 'fallback', 'correction', unless=[self._is_successful]) self.machine.add_transition('verified', 'fallback', 'success', conditions=[self._is_successful]) self.machine.add_transition('verified', 'found_two_spondees', 'success', conditions=[self._is_successful]) self.machine.add_transition('verified', 'found_two_spondees', 'correction', unless=[self._is_successful]) self.machine.add_transition('corrected', 'correction', 'success', conditions=[self._is_successful]) self.machine.add_transition('corrected', 'correction', 'failure', unless=[self._is_successful])
def __init__(self, serial_port_comm): self.state_machine_context = threading.RLock() self.machine = Machine(model=self, states=DriverLogic.states, transitions=DriverLogic.transitions, initial='not_initialized', machine_context=[self.state_machine_context]) self.serial_port_comm = serial_port_comm serial_port_comm.add_flags_observer(self) self.gripper_pos = None self.opening_pos = 29.5 # default gripper values self.closing_pos = 0.5 self.service_sync = threading.Lock() self.operation_params = None self.operation_response = None self.async_operation_finished = threading.Condition() self.no_spurious_wakeup = False self.old_flag_signaled = { "OPEN_SIGNALED": False, "CLOSED_SIGNALED": False, "HOLDING_SIGNALED": False, "FAULT_SIGNALED": False, "IDLE_SIGNALED": False, "OTHER_FAULT_SIGNALED": False, "NOT_INITIALIZED_SIGNALED": True }
def __init__(self): """ Initializes the Model and registers the default state machine transitions available to all models.ctor """ self.state = None self._endpoint_service = None states = [ State(n, on_enter='new_state_entered') for n in _transform_states ] self._machine = Machine(model=self, states=states, initial='started', auto_transitions=False) self._machine.add_transition(trigger='fail', source=list(_transform_states - {'terminated'}), dest='failed') self._machine.add_transition(trigger='ready', source=['started', 'transforming'], dest='ready') self._machine.add_transition(trigger='transform', source=['started', 'ready'], dest='transforming', after='_do_transform') self._machine.add_transition( trigger='terminate', source=list(_transform_states - {'terminating', 'terminated', 'failed'}), dest='terminating', after='_do_terminate') self._machine.add_transition(trigger='terminated', source='terminating', dest='terminated')
def a1(): states = [ 'standing', # 站立 'walking', # 不行 { 'name': 'caffeinated', # 精神抖擞 'initial': 'dithering', 'children':[ 'dithering', # 抖动 'running', # 跑 ] } ] transitions = [ ['walk', 'standing', 'walking'], # 走 : 站立->步行 ['stop', 'walking', 'standing'], # 停 : 步行->站立 ['drink', "standing", 'caffeinated'], # 喝 : *->精神抖擞 ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'], # 走 : ['relax', 'caffeinated', 'standing'], # 放松 : ] machine = Machine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True) # machine.walk() # Walking now # machine.stop() # let's stop for a moment machine.drink() # coffee time print(machine.state)
def test_blueprint_simple(self): states = ['A', 'B', 'C', 'D'] # Define with list of dictionaries transitions = [{ 'trigger': 'walk', 'source': 'A', 'dest': 'B' }, { 'trigger': 'run', 'source': 'B', 'dest': 'C' }, { 'trigger': 'sprint', 'source': 'C', 'dest': 'D' }] m = Machine(states=states, transitions=transitions, before_state_change='before_state_change', after_state_change='after_state_change', initial='A') self.assertEqual(len(m.blueprints['states']), 4) self.assertEqual(m.blueprints['states'][3], 'D') self.assertEqual(len(m.blueprints['transitions']), 3) self.assertEqual(m.blueprints['transitions'][2]['trigger'], 'sprint') m.add_transition('fly', 'D', 'A') self.assertEqual(len(m.blueprints['transitions']), 4) self.assertEqual(m.blueprints['transitions'][3]['source'], 'D')
def a2(): NestedState.separator = '↦' # 配置状态分隔符, 嵌套的状态会自动加上这个符号 states = [ 'A', # 状态 A 'B', # 状态 B { 'name': 'C', # 状态 C 'children':[ '1', '2', # 状态 C↦1 C↦2 { 'name': '3', # 状态 C↦3 'children': [ 'a', 'b', 'c' # 状态 C↦3↦a C↦3↦b C↦3↦c ] } ] } ] transitions = [ # 状态转移表 ['reset', 'C', 'A'], ['reset', 'C↦2', 'C'] # overwriting parent reset ] # we rely on auto transitions machine = Machine(states=states, transitions=transitions, initial='A') machine.to_B() # exit state A, enter state B machine.to_C() # exit B, enter C machine.to_C.s3.a() # enter C↦a; enter C↦3↦a; # 状态为数字, 前面加上 s 字母 print(machine.state) # if __name__ == "__main__": # a2()
def __init__(self): running_states = [ ADCState.RUNNING, ADCState.SUSPENDED_ALLOW_NEW, ADCState.SUSPENDED_NO_NEW ] self.machine = Machine(name='ADC', model=self, states=ADC_STATES, initial=ADCState.UNKNOWN) self.machine.add_transition('init_starting', [ADCState.UNKNOWN], ADCState.STARTING) self.machine.add_transition('done_starting', [ADCState.STARTING], ADCState.RUNNING) self.machine.add_transition( 'shutdown', [ADCState.STARTING, ADCState.STOPPED] + running_states, ADCState.STOPPED) self.machine.add_transition('request_running', running_states, ADCState.RUNNING) self.machine.add_transition('request_suspended_allow_new', running_states, ADCState.SUSPENDED_ALLOW_NEW) self.machine.add_transition('request_suspended_no_new', running_states, ADCState.SUSPENDED_NO_NEW)
def create_statemachine(self, state_machine_model): NestedState.separator = ':' states = [{ 'name': 'base', 'children': ['inactive', 'preparing', 'committed'] }] transitions = [['unavailable', 'base', 'base:inactive'], ['task_created', 'base:inactive', 'base:preparing'], ['commit', 'base:preparing', 'base:committed'], ['no_commit', 'base:committed', 'base:preparing'], ['completed', 'base:committed', 'base:inactive'], ['failed', 'base:committed', 'base:inactive'], ['default', 'base:inactive', 'base:inactive'], ['default', 'base:committed', 'base:committed'], ['default', 'base', 'base']] statemachine = Machine(model=state_machine_model, states=states, transitions=transitions, initial='base', ignore_invalid_triggers=True) statemachine.on_enter('base:inactive', 'INACTIVE') statemachine.on_enter('base:preparing', 'PREPARING') statemachine.on_enter('base:committed', 'COMMITTED') return statemachine
def __init__(self, *cls_args): if not hasattr(cls, 'states') or not cls.states: raise ExceptionNullStatesInMachine if not hasattr(cls, 'init_state') or not cls.init_state: raise ExceptionNullInitState util.logger.spam(f"Wrapped __init__ called") util.logger.spam(f"cls_args is {cls_args}") # self.name = "superman" cls.machine = Machine(model=self, states=cls.states, initial=cls.init_state, ignore_invalid_triggers=True) cls.__init__(cls, *cls_args) for attr_name in dir(cls): attr = getattr(cls, attr_name, None) if not attr: continue info_dict = getattr(attr, "_info_dict_", None) if not info_dict: continue self.machine.add_transition(attr.__name__, **info_dict)
def __init__(self, uuid, morcha): self.states = ['sleeping', 'ringing'] self.morcha = morcha self.uuid = uuid self.machine = Machine(self, states=self.states, initial='start') self.machine.add_transition('ID', 'start', 'ringing', after='after_intrusion_detected') self.machine.add_transition('intrusion_never_happened', 'ringing', 'start')
def __init__(self, *args, **kwargs): super(StateMachineModel, self).__init__(*args, **kwargs) machine = Machine(model=self, states=self._get_init_states(), transitions=self._get_init_transitions(), initial=self.get_initial_state()) setattr(self, 'fsm', machine) setattr(self, "fsm", machine)
def generate_state_machine(): pmodel = ProtoModel("Protocol Model") pmachine = Machine(model=pmodel, states=['0'], initial='0', auto_transitions=False) pmachine.add_transition(exit_label, source='0', dest='0') return pmachine
def __init__(self, direction, credit, serverish): self.machine = Machine(model=self, states=states, initial='IDLE', transitions=transitions) self.direction = direction self.total_credit = credit self.serverish = serverish
def __init__(self): self.machine = Machine(model=self, states=SdkState.states, transitions=SdkState.transitions, send_event=True) self._has_init = False self.network = config.NET_UNKNOWN self._record_list = [] self._crash_list = [] self.state_navi = StateNavi() self.state_cmp = StateCmp()
def create_statemachine(self, state_machine_model): NestedState.separator = ':' states = [{ 'name': 'base', 'children': ['not_ready', 'ready', 'active', 'fail', 'processing'] }] transitions = [['start', 'base', 'base:not_ready'], ['unavailable', 'base', 'base:not_ready'], ['deactivate', 'base', 'base:not_ready'], ['activate', 'base:not_ready', 'base:active'], ['idle', 'base:not_ready', 'base:ready'], ['ready', 'base:ready', 'base:active'], ['activate', 'base:ready', 'base:active'], ['idle', 'base:active', 'base:ready'], ['not_ready', 'base:active', 'base:ready'], ['failure', 'base:active', 'base:fail'], ['active', 'base:active', 'base:processing'], ['idle', 'base:processing', 'base:fail'], ['ready', 'base:processing', 'base:fail'], ['not_ready', 'base:processing', 'base:fail'], ['active', 'base:processing', 'base:fail'], ['activate', 'base:processing', 'base:fail'], ['fail', 'base:processing', 'base:fail'], ['idle', 'base:fail', 'base:ready'], ['ready', 'base:fail', 'base:ready'], ['not_ready', 'base:fail', 'base:ready'], ['active', 'base:fail', 'base:ready'], ['activate', 'base:fail', 'base:ready'], ['failure', 'base:fail', 'base:ready'], ['complete', 'base:fail', 'base:ready'], { 'trigger': 'complete', 'source': 'base:processing', 'dest': 'base:not_ready', 'after': 'COMPLETE' }, ['default', 'base:processing', 'base:fail'], ['default', 'base:fail', 'base:ready'], ['default', 'base:not_ready', 'base:not_ready'], ['default', 'base:ready', 'base:ready'], ['default', 'base:active', 'base:active'], ['reset', '*', 'base:not_ready']] statemachine = Machine(model=state_machine_model, states=states, transitions=transitions, initial='base', ignore_invalid_triggers=True) statemachine.on_enter('base:ready', 'READY') statemachine.on_enter('base:active', 'ACTIVE') statemachine.on_enter('base:not_ready', 'NOT_READY') statemachine.on_enter('base:fail', 'FAILURE') statemachine.on_exit('base:fail', 'complete_failed') statemachine.on_enter('base:processing', 'PROCESSING') return statemachine
def __init__(self, *args, **kwargs): super(Study, self).__init__(*args, **kwargs) self.machine = Machine(self, states=workflow.states, transitions=workflow.transitions, initial=self.state, send_event=True, before_state_change='check_permission', after_state_change='_finalize_state_change')
def test_blueprint_reuse(self): states = ['1', '2', '3'] transitions = [ {'trigger': 'increase', 'source': '1', 'dest': '2'}, {'trigger': 'increase', 'source': '2', 'dest': '3'}, {'trigger': 'decrease', 'source': '3', 'dest': '2'}, {'trigger': 'decrease', 'source': '1', 'dest': '1'}, {'trigger': 'reset', 'source': '*', 'dest': '1'}, ] counter = Machine(states=states, transitions=transitions, before_state_change='check', after_state_change='clear', initial='1') new_states = ['A', 'B', {'name': 'C', 'children': counter}] new_transitions = [ {'trigger': 'forward', 'source': 'A', 'dest': 'B'}, {'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator}, {'trigger': 'backward', 'source': 'C', 'dest': 'B'}, {'trigger': 'backward', 'source': 'B', 'dest': 'A'}, {'trigger': 'calc', 'source': '*', 'dest': 'C'}, ] walker = Machine(states=new_states, transitions=new_transitions, before_state_change='watch', after_state_change='look_back', initial='A') walker.watch = lambda: 'walk' walker.look_back = lambda: 'look_back' walker.check = lambda: 'check' walker.clear = lambda: 'clear' with self.assertRaises(MachineError): walker.increase() self.assertEqual(walker.state, 'A') walker.forward() walker.forward() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.increase() self.assertEqual(walker.state, 'C%s2' % State.separator) walker.reset() self.assertEqual(walker.state, 'C%s1' % State.separator) walker.to_A() self.assertEqual(walker.state, 'A') walker.calc() self.assertEqual(walker.state, 'C')
def __init__(self, robot, testing_mode=False): self.robot = robot self.testing_mode = testing_mode # Initialize the state machine self.state_machine = Machine(model=self, states=self.STATES, queued=True, initial="start") self.state_machine.add_transition( trigger="starting_up", source="start", dest="started", after=lambda *args, **kwargs: starting_up(self, *args, **kwargs)) self.state_machine.add_transition( trigger="initializing", source="started", dest="initialized", after=lambda *args, **kwargs: initializing(self, *args, **kwargs)) self.state_machine.add_transition( trigger="detecting_face", source="*", dest="face_detected", after=lambda *args, **kwargs: recognizing_face( self, *args, **kwargs)) self.state_machine.add_transition( trigger="question_intention", source="face_detected", dest="intention_recognized", after=lambda *args, **kwargs: intention_recognizing( self, *args, **kwargs)) self.state_machine.add_transition( trigger="validate_entry", source=["intention_recognized", "validate_card"], dest="validate_card", after=lambda *args, **kwargs: validation_card_reading( self, *args, **kwargs)) self.state_machine.add_transition( trigger="move_to_side", source="validate_card", dest="on_side", after=lambda *args, **kwargs: move_to_side(self, *args, **kwargs)) self.state_machine.add_transition( trigger="move_back", source="on_side", dest="initialized", after=lambda *args, **kwargs: move_back(self, *args, **kwargs)) self.state_machine.add_transition( trigger="re_initialize", source="*", dest="initialized", after=lambda *args, **kwargs: initializing(self, *args, **kwargs))
def test_wrong_nesting(self): correct = ['A', {'name': 'B', 'children': self.stuff.machine}] wrong_type = ['A', {'name': 'B', 'children': self.stuff}] siblings = ['A', {'name': 'B', 'children': ['1', self.stuff.machine]}] collision = ['A', {'name': 'B', 'children': ['A', self.stuff.machine]}] m = Machine(states=correct) m.to_B.C.s3.a() with self.assertRaises(ValueError): m = Machine(states=wrong_type) with self.assertRaises(ValueError): m = Machine(states=collision) m = Machine(states=siblings) m.to_B.s1() m.to_B.A()
def __init__(self, **kwargs): self.states = [] self.transitions = [] self.isStopping = False self.init_states() self.machine = Machine(model=self, states=self.states, transitions=self.transitions, initial='initial', queued=True, auto_transitions=True, title="Queued State Machine", show_conditions=True)
def __init__(self, init, initial_heading): self.machine = Machine(model=self, states=topomap.states, initial=init) self.last_state = init self.current_heading = initial_heading for i in range(21): for j in range(4): num = self.map[i]['action'][j] if num != -1: self.machine.add_transition(trigger=self.actions[j], source=str(i + 1), dest=str(num + 1))
def __init__(self, uuid, post=None, current_state='secure', intrusion_attempts=0, latest_intrusion_start_time=None, latest_intrusion_end_time=None): self.uuid = uuid self.post = post self.start_time = latest_intrusion_start_time self.end_time = latest_intrusion_end_time self.machine = Machine(model=self, states=morcha_states, transitions=morcha_transitions, initial='secure', ignore_invalid_triggers=True, auto_transitions=False, show_conditions=True) self.insert = True self.intrusion_attempts = intrusion_attempts self.graph.draw('my_machine.png', prog='dot')
def __init__(self,*args, **kwargs): super(StateMachineModel, self).__init__(*args,**kwargs) initial = self._get_initial() machine = Machine(model=self, states=self._get_states(), transitions=self.get_transitions(), auto_transitions=False, initial=initial, send_event=True) self.fsm = machine
def __init__(self): logging.debug('Initializing System...') self.player = player_module self.player.play_media() logging.debug('VLC player initialized..Setting up machine..') self.machine = Machine(model=self, states=MusicMachine.states, initial=states.MOBILE_DISCONNECTED) self.machine.add_transition(trigger=triggers.MOBILE_CONNECTED, source=states.MOBILE_DISCONNECTED, dest=states.MOBILE_CONNECTED, before='trigger_device_connection') self.machine.add_transition( trigger=triggers.MOBILE_DISCONNECTED, source=[states.MOBILE_CONNECTED, states.PLAYING], dest=states.MOBILE_DISCONNECTED, before='trigger_device_disconnect') self.machine.add_transition(trigger=triggers.MOBILE_CONNECTED, source=states.MOBILE_CONNECTED, dest=states.PLAYING) self.machine.add_transition(trigger=triggers.MOBILE_CONNECTED, source=states.PLAYING, dest=states.PLAYING) self.machine.add_transition(trigger=triggers.MOBILE_DISCONNECTED, source=states.MOBILE_DISCONNECTED, dest=states.MOBILE_DISCONNECTED) self.machine.add_transition(trigger=triggers.MOBILE_DISCONNECTED, source=states.MANUALLY_PAUSED, dest=states.MANUALLY_PAUSED) self.machine.add_transition(trigger=triggers.MOBILE_DISCONNECTED, source=states.PLAYING, dest=states.MOBILE_DISCONNECTED, before='trigger_device_disconnect') self.machine.add_transition(trigger=triggers.MANUAL_PLAY, source=MusicMachine.states, dest=states.PLAYING, before='trigger_device_connection') self.machine.add_transition(trigger=triggers.MANUAL_PAUSE, source=MusicMachine.states, dest=states.MANUALLY_PAUSED, before='trigger_device_disconnect') logging.debug('Machine Setup Completed..')
def get_machine(pstate, ptitle): class Model(object): pass m = Model() machine = Machine(model=m, states=STATES, transitions=TRANSITIONS, initial=pstate, title=ptitle) return machine