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
