コード例 #1
0
    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
コード例 #2
0
class ConnectionStateMachine:
    """HSMS Connection state machine."""
    def __init__(self, callbacks=None):
        """
        Initialize the hsms connection state machine.

        :param callbacks: callbacks for the state machine
        """
        self.callbacks = {}

        self.states = [
            STATE_NOT_CONNECTED, {
                'name':
                STATE_CONNECTED,
                'on_enter':
                self._on_enter_CONNECTED,
                'on_exit':
                self._on_exit_CONNECTED,
                'children': [
                    STATE_NOT_SELECTED, {
                        'name': STATE_SELECTED,
                        'on_enter': self._on_enter_CONNECTED_SELECTED
                    }
                ]
            }
        ]

        # transition 1
        self.machine = Machine(model=self,
                               states=self.states,
                               initial=STATE_NOT_CONNECTED,
                               auto_transitions=False)

        if callbacks:
            self.callbacks = callbacks

        self.machine.add_transition(
            'connect', STATE_NOT_CONNECTED,
            STATE_CONNECTED_NOT_SELECTED)  # transition 2
        self.machine.add_transition('disconnect', STATE_CONNECTED,
                                    STATE_NOT_CONNECTED)  # transition 3
        self.machine.add_transition('select', STATE_CONNECTED_NOT_SELECTED,
                                    STATE_CONNECTED_SELECTED)  # transition 4
        self.machine.add_transition(
            'deselect', STATE_CONNECTED_SELECTED,
            STATE_CONNECTED_NOT_SELECTED)  # transition 5
        self.machine.add_transition('timeoutT7', STATE_CONNECTED_NOT_SELECTED,
                                    STATE_NOT_CONNECTED)  # transition 6

    def _on_enter_CONNECTED(self):
        if "on_enter_CONNECTED" in self.callbacks:
            self.callbacks["on_enter_CONNECTED"]()

    def _on_exit_CONNECTED(self):
        if "on_exit_CONNECTED" in self.callbacks:
            self.callbacks["on_exit_CONNECTED"]()

    def _on_enter_CONNECTED_SELECTED(self):
        if "on_enter_CONNECTED_SELECTED" in self.callbacks:
            self.callbacks["on_enter_CONNECTED_SELECTED"]()
コード例 #3
0
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()
コード例 #4
0
ファイル: mission_controller.py プロジェクト: pryme/neobot
 def __init__(self, num_edges):
     self.max_edges = num_edges  # stops seeking after finding this many edges
     self.reset_edge_count()
     self.ch = CliffHandler()
     self.states = [
         'idle', 'edge_finding', {
             'name': 'clearing',
             'children': self.ch,
             'remap': {
                 'done': 'cleared'
             }
         }, {
             'name': 'cleared',
             'on_enter': 'check_if_done'
         }, 'final_move', 'mission_complete'
     ]
     Machine.__init__(self, states=self.states, initial='idle')
     self.add_transition('start',
                         'idle',
                         'edge_finding',
                         before=['reset_edge_count'])
     self.add_transition('at_cliff',
                         'edge_finding',
                         'clearing',
                         before=['increment_edge_count'],
                         after='to_clearing_angle_finding')
     self.add_transition('at_goal', 'final_move', 'mission_complete')
コード例 #5
0
ファイル: test_reuse.py プロジェクト: DDecoene/transitions
    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()
コード例 #6
0
    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')
コード例 #7
0
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)
コード例 #8
0
ファイル: test_reuse.py プロジェクト: vdthatte/transitions
    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()
コード例 #9
0
ファイル: test_reuse.py プロジェクト: Coverfox/transitions
    def test_blueprint_nested(self):
        c1 = NestedState('C_1', parent='C')
        c2 = NestedState('C_2', parent='C')
        c3 = NestedState('C_3', parent='C')
        c = NestedState('C', children=[c1, c2, c3])

        states = ['A', {'name': 'B', 'on_enter': 'chirp', 'children': ['1', '2', '3']},
                  c, 'D']
        # Define with list of dictionaries
        transitions = [
            {'trigger': 'walk', 'source': 'A', 'dest': 'B','before': 'before_state_change',
             'after': 'after_state_change' },
            {'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')

        m.before_state_change = MagicMock()
        m.after_state_change = MagicMock()

        self.assertEqual(len(m.blueprints['states']), 4)
        self.assertEqual(m.blueprints['states'][3], 'D')
        self.assertEqual(len(m.blueprints['transitions']), 3)
        # transition 'walk' before should contain two calls of the same method
        self.assertEqual(len(m.blueprints['transitions'][0]['before']), 2)
        self.assertEqual(len(m.blueprints['transitions'][0]['after']), 2)
        self.assertEqual(len(m.blueprints['transitions'][1]['before']), 1)
        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')
コード例 #10
0
    def __init__(self):
        self.nested = Nested(self)

        self.states = ['t1', {'name': 't2', 'children': self.nested}]
        Machine.__init__(self, states=self.states, initial='t1')
        self.add_transition(trigger='print_top',
                            source='*',
                            dest='=',
                            after=self.print_msg)
        self.add_transition(trigger='goto_t2', source='*', dest='t2_n1')
コード例 #11
0
ファイル: mission_controller.py プロジェクト: pryme/neobot
 def __init__(self):
     self.states = [{
         'name': 'angle_finding',
         'on_enter': self.save_start_pose,
         'on_exit': self.save_end_pose
     }, 'aligning', 'backing', 'spinning', 'done']
     Machine.__init__(self, states=self.states, initial='angle_finding')
     self.add_transition('at_cliff', 'angle_finding', 'aligning')
     self.add_transition('at_goal', 'aligning', 'backing')
     self.add_transition('at_goal', 'backing', 'spinning')
     self.add_transition('at_goal', 'spinning', 'done')
     self.add_transition('at_goal', 'angle_finding', 'backing')
     self.add_transition('at_cliff', 'aligning', 'backing')
コード例 #12
0
    def test_blueprint_nested(self):
        c1 = NestedState('C_1', parent='C')
        c2 = NestedState('C_2', parent='C')
        c3 = NestedState('C_3', parent='C')
        c = NestedState('C', children=[c1, c2, c3])

        states = [
            'A', {
                'name': 'B',
                'on_enter': 'chirp',
                'children': ['1', '2', '3']
            }, c, 'D'
        ]
        # Define with list of dictionaries
        transitions = [{
            'trigger': 'walk',
            'source': 'A',
            'dest': 'B',
            'before': 'before_state_change',
            'after': 'after_state_change'
        }, {
            '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')

        m.before_state_change = MagicMock()
        m.after_state_change = MagicMock()

        self.assertEqual(len(m.blueprints['states']), 4)
        self.assertEqual(m.blueprints['states'][3], 'D')
        self.assertEqual(len(m.blueprints['transitions']), 3)
        # transition 'walk' before should contain two calls of the same method
        self.assertEqual(len(m.blueprints['transitions'][0]['before']), 2)
        self.assertEqual(len(m.blueprints['transitions'][0]['after']), 2)
        self.assertEqual(len(m.blueprints['transitions'][1]['before']), 1)
        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')
コード例 #13
0
	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])
コード例 #14
0
ファイル: test_reuse.py プロジェクト: Coverfox/transitions
    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')
コード例 #15
0
class SimpleFSA(annotator):
	
	_states = [
	{'name': 'waiting', 'on_enter': '_reset_positions'},
	{'name': 'analysing'},
	{'name': 'finished'}
	]

	def __init__(self, name):
		annotator.__init__(self, name)
		self.machine = Machine(model=self, states=SimpleFSA._states, initial='waiting')
		self.machine.add_transition(trigger='start_analysis', source='waiting', dest='analysing', after='_analyse')
		self.machine.add_transition('corrected', 'analysing', 'finished')

	def verify(self, line):
		return annotator._verify_string(self, line)
	
	def _analyse(self):
		annotator._correct(self)
コード例 #16
0
class ConnectionStateMachine(object):
    states = [
        "NOT_CONNECTED", {
            'name': 'CONNECTED',
            'children': ['NOT_SELECTED', 'SELECTED']
        }
    ]

    def __init__(self, callbacks=None):
        self.machine = Machine(model=self,
                               states=ConnectionStateMachine.states,
                               initial='NOT_CONNECTED',
                               auto_transitions=False,
                               queued=True)  # transition 1

        if callbacks is None:
            self.callbacks = {}
        else:
            self.callbacks = callbacks

        self.machine.add_transition('connect', 'NOT_CONNECTED',
                                    'CONNECTED_NOT_SELECTED')  # transition 2
        self.machine.add_transition('disconnect', 'CONNECTED',
                                    'NOT_CONNECTED')  # transition 3
        self.machine.add_transition('select', 'CONNECTED_NOT_SELECTED',
                                    'CONNECTED_SELECTED')  # transition 4
        self.machine.add_transition('deselect', 'CONNECTED_SELECTED',
                                    'CONNECTED_NOT_SELECTED')  # transition 5
        self.machine.add_transition('timeoutT7', 'CONNECTED_NOT_SELECTED',
                                    'NOT_CONNECTED')  # transition 6

    def on_enter_CONNECTED(self):
        if "on_enter_CONNECTED" in self.callbacks:
            self.callbacks["on_enter_CONNECTED"]()

    def on_exit_CONNECTED(self):
        if "on_exit_CONNECTED" in self.callbacks:
            self.callbacks["on_exit_CONNECTED"]()

    def on_enter_CONNECTED_SELECTED(self):
        if "on_enter_CONNECTED_SELECTED" in self.callbacks:
            self.callbacks["on_enter_CONNECTED_SELECTED"]()
コード例 #17
0
    def __init__(self,
                 server_uri: tuple = None,
                 ssl_mode=False,
                 cert_path=CERT_PATH):
        """
        客户端初始化
        :param server_uri: 服务器地址
        :param ssl_mode: 是否使用SSL
        :param cert_path: 服务器证书路径
        """
        # 状态机初始化
        Machine.__init__(self,
                         states=STATES,
                         transitions=TRANSITIONS,
                         initial="INIT",
                         send_event=True,
                         **extra_args)
        self.__machine_init()

        # socket初始化
        self.raw_sock = socket.create_connection(server_uri)
        self.work_sock = None
        if ssl_mode:
            print('使用SSL模式加密传输')
            self.context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
            self.context.load_verify_locations(cert_path)
            self.work_sock = self.context.wrap_socket(
                self.raw_sock, server_hostname=server_uri[0])
        else:
            print('不使用SSL')
            self.work_sock = self.raw_sock
        # 其他参数
        self.file_sock = None  # 传输文件专用 socket
        # 下载文件专用监听socket
        # self.down_listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # self.down_listen_sock.bind((SERVER_HOST, SERVER_DATA_PORT))
        # self.down_conn_sock = None  # 下载文件连接socket
        self.token = None  # 用户临时口令
コード例 #18
0
ファイル: machine.py プロジェクト: sina33/asef
 def __init__(self):
     NestedState.separator = '>'
     states = ['Main',
               {'name': 'Profile', 'children': ['Gender', 'Age']},
               {'name': 'Test1', 'children': [str(i) for i in range(1, 11)]},
               'Result1',
               {'name': 'Test2', 'children': ['1', '2', {'name': '3', 'children': [str(i) for i in range(1, 8)]}]},
               'Result2'
               'Wait',
               'Admin'
               ]
     transitions = [
         ['profile', 'Main', 'Profile>Gender'],
         ['next_q', 'Profile>Gender', 'Profile>Age'],
         ['test1', 'Main', 'Test1>1'],
         ['result1', 'Test1>10', 'Result1'],
         ['test2', 'Main', 'Test2>1'],
         ['result2', 'Test2>3>7', 'Result2'],
         ['reset', '*', 'Main'],
         ['admin', '*', 'Admin']
     ]
     HierarchicalMachine.__init__(self, states=states, transitions=transitions, initial='Main')
                                  # before_state_change='before_transition',
                                  # after_state_change='after_transition')
     st_list = list(['Test1>{0}'.format(i) for i in range(1, 11)])
     st_list.append('Result1')
     self.add_ordered_transitions(trigger='next_q', states=st_list, loop=False)
     st_list = list(['Test2>3>{0}'.format(i) for i in range(1, 8)])
     st_list.append('Result2')
     self.add_ordered_transitions(trigger='next_q', states=st_list, loop=False)
     self.add_ordered_transitions(trigger='next_part', states=['Test2>1', 'Test2>2', 'Test2>3>1'], loop=False)
     self.t2_dream_category = int()
     self.t2_dream_subject = int()
     self.add_transition(trigger='wait', source='*', dest='Wait', before='before_wait', conditions=['proceed'])
     self.previous_state = 'Main'
     self.is_waiting = False
     self.wait_interrupted = False
コード例 #19
0
	def __init__(self, name):
		annotator.__init__(self, name)
		self.machine = Machine(model=self, states=HFSA16._states, initial='waiting')
		self.machine.add_transition(trigger='start_analysis', source='waiting', dest='searching_for_spondeus_secondF', after='_search_second')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_secondF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_secondF', 'searching_for_spondeus_firstF', after='_search_first')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_firstF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_firstF', 'searching_for_spondeus_fourthF', after='_search_fourth')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_fourthF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_fourthF', 'searching_for_spondeus_thirdF', after='_search_third')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_thirdF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_thirdF', 'searching_for_spondeus_fifthF', after='_search_fifth')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_fifthF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_fifthF', 'no_spondeus_found')
		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', 'spondeus_found', 'success', conditions=[self._is_successful])
		self.machine.add_transition('verified', 'spondeus_found', '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])
コード例 #20
0
    def __init__(self, callbacks=None):
        self.machine = Machine(model=self,
                               states=ConnectionStateMachine.states,
                               initial='NOT_CONNECTED',
                               auto_transitions=False,
                               queued=True)  # transition 1

        if callbacks is None:
            self.callbacks = {}
        else:
            self.callbacks = callbacks

        self.machine.add_transition('connect', 'NOT_CONNECTED',
                                    'CONNECTED_NOT_SELECTED')  # transition 2
        self.machine.add_transition('disconnect', 'CONNECTED',
                                    'NOT_CONNECTED')  # transition 3
        self.machine.add_transition('select', 'CONNECTED_NOT_SELECTED',
                                    'CONNECTED_SELECTED')  # transition 4
        self.machine.add_transition('deselect', 'CONNECTED_SELECTED',
                                    'CONNECTED_NOT_SELECTED')  # transition 5
        self.machine.add_transition('timeoutT7', 'CONNECTED_NOT_SELECTED',
                                    'NOT_CONNECTED')  # transition 6
コード例 #21
0
ファイル: wholeshow.py プロジェクト: linas/HEAD
    def __init__(self):
        rospy.wait_for_service('/performances/reload_properties')

        # States for wholeshow
        states = [{'name': 'sleeping', 'children': ['shutting']},
                  {'name': 'interacting', 'children': ['nonverbal']},
                  'performing', 'opencog', 'analysis']
        HierarchicalMachine.__init__(self, states=states, initial='interacting')
        # Transitions
        self.add_transition('wake_up', 'sleeping', 'interacting')
        # Transitions
        self.add_transition('perform', 'interacting', 'performing')
        self.add_transition('interact', 'performing', 'interacting')
        self.add_transition('start_opencog', 'interacting', 'opencog')
        self.add_transition('shut', 'sleeping', 'sleeping_shutting')
        self.add_transition('be_quiet', 'interacting', 'interacting_nonverbal')
        self.add_transition('start_talking', 'interacting_nonverbal', 'interacting')
        # States handling
        self.on_enter_sleeping("start_sleeping")
        self.on_exit_sleeping("stop_sleeping")
        self.on_enter_interacting("start_interacting")
        self.on_exit_interacting("stop_interacting")
        self.on_enter_sleeping_shutting("system_shutdown")
        # ROS Handling
        rospy.init_node('WholeShow')
        self.btree_pub = rospy.Publisher("/behavior_switch", String, queue_size=5)
        self.btree_sub = rospy.Subscriber("/behavior_switch", String, self.btree_cb)
        self.soma_pub = rospy.Publisher('/blender_api/set_soma_state', SomaState, queue_size=10)
        self.look_pub = rospy.Publisher('/blender_api/set_face_target', Target, queue_size=10)
        self.gaze_pub = rospy.Publisher('/blender_api/set_gaze_target', Target, queue_size=10)
        self.performance_runner = rospy.ServiceProxy('/performances/run_full_performance', srv.RunByName)
        # Wholeshow starts with behavior enabled, unless set otherwise
        rospy.set_param("/behavior_enabled", rospy.get_param("/behavior_enabled", True))
        # Start sleeping. Wait for Blender to load
        rospy.wait_for_service('/blender_api/set_param')
        rospy.wait_for_service('/performances/current')
        self.blender_param = rospy.ServiceProxy('/blender_api/set_param', SetParam)
        time.sleep(2)
        self.sleeping = rospy.get_param('start_sleeping', False)
        if self.sleeping:
            t = threading.Timer(1, self.to_sleeping)
            t.start()
        # Performance id as key and keyword array as value
        self.performances_keywords = {}
        # Parse on load.
        # TODO make sure we reload those once performances are saved.
        self.after_performance = False
        # Speech handler. Receives all speech input, and forwards to chatbot if its not a command input,
        #  or chat is enabled
        self.speech_sub = rospy.Subscriber('speech', ChatMessage, self.speech_cb)
        self.speech_pub = rospy.Publisher('chatbot_speech', ChatMessage, queue_size=10)
        # Sleep
        self.performance_events = rospy.Subscriber('/performances/events', Event, self.performances_cb)
        # Dynamic reconfigure
        self.config = {}
        self.cfg_srv = Server(WholeshowConfig, self.config_cb)
        # Behavior was paused entering into state
        self.behavior_paused = False
        # Chatbot was paused entering the state
        self.chatbot_paused = False
        self.sleeping = rospy.get_param('start_sleeping', False)
        # Preferred speech source
        self.speech_provider = rospy.get_param("active_stt", 'cloudspeech')
        self.speech_provider_active = False
        rospy.Subscriber('{}/status'.format(self.speech_provider), Bool, self.stt_status_cb)
コード例 #22
0
class HFSA16(annotator):

	_states = [
	{'name': 'waiting', 'on_enter': '_reset_positions'},
	{'name': 'searching_for_spondeus', 'children': ['secondF', 'firstF', 'fourthF', 'thirdF', 'fifthF']},
	{'name': 'spondeus_found', 'on_enter': '_verify_output'},
	{'name': 'no_spondeus_found', 'on_enter': '_make_spondeus'},
	{'name': 'fallback', 'on_enter': '_search_whole'},
	{'name': 'correction', 'on_enter': '_correct'},
	'success',
	'failure'
	]
	
	def __init__(self, name):
		annotator.__init__(self, name)
		self.machine = Machine(model=self, states=HFSA16._states, initial='waiting')
		self.machine.add_transition(trigger='start_analysis', source='waiting', dest='searching_for_spondeus_secondF', after='_search_second')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_secondF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_secondF', 'searching_for_spondeus_firstF', after='_search_first')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_firstF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_firstF', 'searching_for_spondeus_fourthF', after='_search_fourth')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_fourthF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_fourthF', 'searching_for_spondeus_thirdF', after='_search_third')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_thirdF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_thirdF', 'searching_for_spondeus_fifthF', after='_search_fifth')
		self.machine.add_transition('found_spondeus', 'searching_for_spondeus_fifthF', 'spondeus_found')
		self.machine.add_transition('not_found', 'searching_for_spondeus_fifthF', 'no_spondeus_found')
		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', 'spondeus_found', 'success', conditions=[self._is_successful])
		self.machine.add_transition('verified', 'spondeus_found', '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 _search_second(self):
		fourth = self._search_long(4)
		fifth = self._search_long(5)
		if fourth and fifth:
			self.verse.scansion = '-** -- -** -** -** -X'
			self.found_spondeus()
		elif fourth:
			self.positions.append(4)
			self.not_found()
		elif fifth:
			self.positions.append(5)
			self.not_found()
		else:
			self.not_found()
		
	def _search_first(self):
		if self._search_long(2):
			self.verse.scansion = '-- -** -** -** -** -X'
			self.found_spondeus()
		else:
			self.not_found()
			
	def _search_fourth(self):
		tenth = self._search_long(10)
		eleventh = self._search_long(11)
		if tenth and eleventh:
			self.verse.scansion = '-** -** -** -- -** -X'
			self.found_spondeus()
		elif tenth:
			self.positions.append(10)
			self.not_found()
		elif eleventh:
			self.positions.append(11)
			self.not_found()
		else:
			self.not_found()

	def _search_third(self):
		seventh = self._search_long(7)
		eigth = self._search_long(8)
		if seventh and eigth:
			self.verse.scansion = '-** -** -- -** -** -X'
			self.found_spondeus()
		elif seventh:
			self.positions.append(7)
			self.not_found()
		elif eigth:
			self.positions.append(8)
			self.not_found()
		else:
			self.not_found()
			
	def _search_fifth(self):
		thirteenth = self._search_long(13)
		fourteenth = self._search_long(14)
		if thirteenth and fourteenth:
			self.verse.scansion = '-** -** -** -** -- -X'
			self.found_spondeus()
		elif thirteenth:
			self.positions.append(13)
			self.not_found()
		elif fourteenth:
			self.positions.append(14)
			self.not_found()
		else:
			self.not_found()
			
	def _make_spondeus(self):
		annotator._make_spondeus(self, 14)
コード例 #23
0
    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
コード例 #24
0
class HFSA15(annotator):

	_states = [
	{'name': 'waiting', 'on_enter': '_reset_positions'},
	{'name': 'searching_for_first_spondeus', 'children': ['secondF', 'firstF', 'fourthF', 'thirdF']}, 
	{'name': 'searching_for_second_spondeus', 'children': ['firstF', 'fourthF', 'thirdF', 'fifthF']},
	{'name': 'no_spondeus_found', 'on_enter': '_make_spondeus'},
	{'name': 'found_two_spondees', 'on_enter': '_make_scansion'}, 
	{'name': 'fallback', 'on_enter': '_search_whole'},
	{'name': 'correction', 'on_enter': '_correct'},
	'success',
	'failure'
	]

	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 _search_second(self):
		third = self._search_long(3)
		fourth = self._search_long(4)
		fifth = self._search_long(5)
		if third and fourth:
			self.positions.append(3)
			self.positions.append(4)
			self._set_found()
		elif fourth and fifth:
			self.positions.append(4)
			self.positions.append(5)
			self._set_found()
		else:
			if third:
				self.positions.append(3)
			if fourth:
				self.positions.append(4)
			if fifth:
				self.positions.append(5)
		self.search_spondeus()
		
	def _search_first(self):
		first = self._search_long(1)
		second = self._search_long(2)
		if first and second:
			self.positions.append(1)
			self.positions.append(2)
			self._set_found()
		elif first:
			self.positions.append(1)
		elif second:
			self.positions.append(2)
		self.search_spondeus()
		
	def _search_fourth(self):
		ninth = self._search_long(9)
		tenth = self._search_long(10)
		eleventh = self._search_long(11)
		if tenth and eleventh:
			self.positions.append(10)
			self.positions.append(11)
			self._set_found()
		elif ninth and tenth:
			self.positions.append(9)
			self.positions.append(10)
			self._set_found()
		else:
			if ninth:
				self.positions.append(9)
			if tenth:
				self.positions.append(10)
			if eleventh:
				self.positions.append(11)
		self.search_spondeus()
		
	def _search_third(self):
		sixth = self._search_long(6)
		seventh = self._search_long(7)
		eigth = self._search_long(8)
		if seventh and eigth:
			self.positions.append(7)
			self.positions.append(8)
			self._set_found()
		elif sixth and seventh:
			self.positions.append(6)
			self.positions.append(7)
			self._set_found()
		else:
			if sixth:
				self.positions.append(6)
			if seventh:
				self.positions.append(7)
			if eigth:
				self.positions.append(8)
		self.search_spondeus()
		
	def _search_fifth(self):
		twelfth = self._search_long(12)
		thirteenth = self._search_long(13)
		if twelfth and thirteenth:
			self.positions.append(12)
			self.positions.append(13)
			self._set_found()
		elif twelfth:
			self.positions.append(12)
		elif thirteenth:
			self.positions.append(13)
		self.search_spondeus()
		
	def _make_scansion(self):
		if 2 in self.positions:
			self.verse.scansion = '-- '
			if 4 in self.positions:
				self.verse.scansion+= '-- -** -** -** -X'
				self._verify_output()
			elif 7 in self.positions:
				self.verse.scansion+= '-** -- -** -** -X'
				self._verify_output()
			elif 10 in self.positions:
				self.verse.scansion+= '-** -** -- -** -X'
				self._verify_output()
			elif 13 in self.positions:
				self.verse.scansion+= '-** -** -** -- -X'
				self._verify_output()
			else:
				self.search_spondeus()
		elif 5 in self.positions:
			self.verse.scansion = '-** -- '
			if 7 in self.positions:
				self.verse.scansion+= '-- -** -** -X'
				self._verify_output()
			elif 10 in self.positions:
				self.verse.scansion+= '-** -- -** -X'
				self._verify_output()
			elif 13 in self.positions:
				self.verse.scansion+= '-** -** -- -X'
				self._verify_output()
			else:
				self.search_spondeus()
		elif 8 in self.positions:
			self.verse.scansion = '-** -** -- '
			if 10 in self.positions:
				self.verse.scansion+= '-- -** -X'
				self._verify_output()
			elif 13 in self.positions:
				self.verse.scansion+= '-** -- -X'
				self._verify_output()
			else:
				self.search_spondeus()
		elif 11 in self.positions:
			self.verse.scansion = '-** -** -** -- -- -X'
			self._verify_output()
		else:
			self.search_spondeus()
			
	def _make_spondeus(self):
		annotator._make_spondeus(self, 13)
コード例 #25
0
ファイル: test_reuse.py プロジェクト: tyarkoni/transitions
 def test_blueprint_initial_false(self):
     child = Machine(states=['A', 'B'], initial='A')
     parent = Machine(states=['a', 'b', {'name': 'c', 'children': child, 'initial': False}])
     parent.to_c()
     self.assertEqual(parent.state, 'c')
コード例 #26
0
ファイル: test_reuse.py プロジェクト: wtgee/transitions
    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')
コード例 #27
0
    def create_statemachine(self, state_machine_model):
        NestedState.separator = ':'

        states = [{
            'name':
            'base',
            'children': [
                'activated', {
                    'name':
                    'operational',
                    'children': [
                        'loading', 'cycle_start', 'unloading', 'idle',
                        'in_transition'
                    ]
                }, {
                    'name': 'disabled',
                    'children': ['fault', 'not_ready']
                }
            ]
        }]

        transitions = [
            ['start', 'base', 'base:disabled'],
            ['cnc_controller_mode_automatic', 'base', 'base:activated'],
            ['reset_cnc', 'base', 'base:activated'],
            ['enable', 'base', 'base:activated'],
            ['disable', 'base', 'base:activated'],
            ['cnc_controller_mode_manual', 'base', 'base:activated'],
            [
                'cnc_controller_mode_manual_data_input', 'base',
                'base:activated'
            ],
            [
                'cnc_controller_mode_automatic', 'base:disabled',
                'base:activated'
            ],
            ['robot_material_load_ready', 'base:disabled', 'base:activated'],
            ['robot_material_unload_ready', 'base:disabled', 'base:activated'],
            [
                'default', 'base:operational:cycle_start',
                'base:operational:cycle_start'
            ], {
                'trigger': 'complete',
                'source': 'base:operational:loading',
                'dest': 'base:operational:cycle_start',
                'before': 'LOADED'
            },
            [
                'complete', 'base:operational:in_transition',
                'base:operational:loading'
            ], {
                'trigger': 'complete',
                'source': 'base:operational:unloading',
                'dest': 'base:operational:in_transition',
                'before': 'UNLOADED'
            }, ['fault', 'base', 'base:disabled:fault'],
            ['robot_system_fault', 'base', 'base:disabled:fault'],
            ['default', 'base:disabled:fault', 'base:disabled:fault'],
            ['faulted', 'base:activated', 'base:disabled:fault'],
            [
                'cnc_fault', 'base:operational:cycle_start',
                'base:disabled:fault'
            ], ['start', 'base:disabled', 'base:disabled:not_ready'],
            ['default', 'base:disabled:not_ready', 'base:disabled:not_ready'],
            ['default', 'base:disabled', 'base:disabled:not_ready'],
            ['still_not_ready', 'base:activated', 'base:disabled:not_ready'],
            ['loading', 'base:operational', 'base:operational:loading'],
            [
                'default', 'base:operational:loading',
                'base:operational:loading'
            ], ['unloading', 'base:operational', 'base:operational:unloading'],
            [
                'default', 'base:operational:unloading',
                'base:operational:unloading'
            ],
            [
                'cnc_execution_ready', 'base:operational:cycle_start',
                'base:operational:unloading'
            ], ['failed', 'base:operational:loading', 'base:operational:idle'],
            ['failed', 'base:operational:unloading', 'base:operational:idle'],
            ['start', 'base:operational', 'base:operational:idle'], {
                'trigger': 'robot_material_unload_ready',
                'source': 'base:operational:idle',
                'dest': 'base:operational',
                'after': 'EXITING_IDLE'
            }, {
                'trigger': 'robot_material_load_ready',
                'source': 'base:operational:idle',
                'dest': 'base:operational',
                'after': 'EXITING_IDLE'
            }, ['default', 'base:operational:idle', 'base:operational:idle'],
            ['make_operational', 'base:activated', 'base:operational']
        ]

        statemachine = Machine(model=state_machine_model,
                               states=states,
                               transitions=transitions,
                               initial='base',
                               ignore_invalid_triggers=True)

        statemachine.on_enter('base:disabled', 'CNC_NOT_READY')
        statemachine.on_enter('base:disabled:not_ready', 'CNC_NOT_READY')
        statemachine.on_enter('base:disabled:fault', 'CNC_NOT_READY')
        statemachine.on_enter('base:activated', 'ACTIVATE')
        statemachine.on_enter('base:operational', 'OPERATIONAL')
        statemachine.on_enter('base:operational:idle', 'IDLE')
        statemachine.on_enter('base:operational:cycle_start', 'CYCLING')
        statemachine.on_enter('base:operational:loading', 'LOADING')
        statemachine.on_enter('base:operational:unloading', 'UNLOADING')
        statemachine.on_enter('base:operational:in_transition',
                              'IN_TRANSITION')
        statemachine.on_exit('base:operational:in_transition',
                             'EXIT_TRANSITION')

        return statemachine
コード例 #28
0
ファイル: statemachine.py プロジェクト: luyh/heroku
from states import states
import time
import threading
from ulity import china_time, send_email

# # Set up logging; The basic log level will be DEBUG
# import logging
# logging.basicConfig(level=logging.DEBUG)
# # Set transitions' log level to INFO; DEBUG messages will be omitted
# logging.getLogger('transitions').setLevel(logging.INFO)

threadLock = threading.Lock()
threads = []

hpg = HPG()
machine = Machine(hpg, states=states, initial='initial')
####
machine.add_transition('connect_chrome',
                       'initial',
                       'connectedChrome',
                       conditions='connectChrome')

#####
machine.add_transition('CheckLogin', '*', 'loginHPG', conditions='check_login')

machine.add_transition('QuereTask',
                       '*',
                       'quereedTask',
                       conditions='queue_task')

machine.add_transition('ReceiveTask',
コード例 #29
0
    def create_statemachine(self, state_machine_model):
        NestedState.separator = ':'

        states = [{
            'name':
            'base',
            'children': [
                'inactive', 'preparing', 'committing', 'committed', 'complete',
                'fail'
            ]
        }, 'removed']

        transitions = [['create', 'base', 'base:inactive'],
                       ['activated', 'base:inactive', 'base:preparing'],
                       ['failure', 'base:inactive', 'base:fail'],
                       ['quorum', 'base:preparing', 'base:committing'],
                       ['all_commit', 'base:committing', 'base:committed'],
                       ['no_commit', 'base:committing', 'base:preparing'],
                       ['success', 'base:committed', 'base:complete'],
                       ['failure', 'base:committed', 'base:fail'],
                       ['default', 'base:complete', 'removed'],
                       ['default', 'base:fail', 'removed'],
                       ['default', 'base:inactive', 'base:inactive'],
                       ['default', 'base:committed', 'base:committed']]

        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:committing', 'COMMITTING')
        statemachine.on_enter('base:committed', 'COMMITTED')
        statemachine.on_enter('base:complete', 'COMPLETE')
        statemachine.on_enter('base:fail', 'FAIL')

        return statemachine
コード例 #30
0
]
transitions = [
    ['slowdown', 'green', 'yellow'],
    ['stop', 'yellow', 'red'],
    ['go', 'red', 'green'],
    ['throw_rock', '*', 'broken'],
    ['evening', 'broken', 'broken_buzzing'],
    ['day', ['broken_sparking', 'broken_buzzing'], 'broken'],

    # Since you have to specify a transition, and a specific
    # state to pop to, this is not a push/pop
    # at all, simply nested states.
    ['pop_broken', 'broken', 'green']
]

machine = Machine(t, states=states, transitions=transitions, initial='green')

# Transitioning from multiple states via the same trigger - pity can't specify this in the transitions structure
machine.add_transition('powersurge', 'broken', 'broken_buzzing')
machine.add_transition('powersurge', 'broken_buzzing', 'broken_sparking')

print(t.state)
assert t.state == 'green'
print(machine.get_state(t.state))

t.slowdown()
t.stop()
print(t.state)
assert t.state == 'red'

# same test as in state-demo2-stack
コード例 #31
0
ファイル: test_reuse.py プロジェクト: Coverfox/transitions
    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'},
            {'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_1')
        walker.increase()
        self.assertEqual(walker.state, 'C_2')
        walker.reset()
        self.assertEqual(walker.state, 'C_1')
        walker.to_A()
        self.assertEqual(walker.state, 'A')
        walker.calc()
        self.assertEqual(walker.state, 'C_1')
コード例 #32
0
    def __init__(self):
        rospy.wait_for_service('/performances/reload_properties')

        # States for wholeshow
        states = [{
            'name': 'sleeping',
            'children': ['shutting']
        }, {
            'name': 'interacting',
            'children': ['nonverbal']
        }, 'performing', 'opencog', 'analysis']
        HierarchicalMachine.__init__(self,
                                     states=states,
                                     initial='interacting')
        # Transitions
        self.add_transition('wake_up', 'sleeping', 'interacting')
        # Transitions
        self.add_transition('perform', 'interacting', 'performing')
        self.add_transition('interact', 'performing', 'interacting')
        self.add_transition('start_opencog', 'interacting', 'opencog')
        self.add_transition('shut', 'sleeping', 'sleeping_shutting')
        self.add_transition('be_quiet', 'interacting', 'interacting_nonverbal')
        self.add_transition('start_talking', 'interacting_nonverbal',
                            'interacting')
        # States handling
        self.on_enter_sleeping("start_sleeping")
        self.on_exit_sleeping("stop_sleeping")
        self.on_enter_interacting("start_interacting")
        self.on_exit_interacting("stop_interacting")
        self.on_enter_sleeping_shutting("system_shutdown")
        # ROS Handling
        rospy.init_node('WholeShow')
        self.btree_pub = rospy.Publisher("/behavior_switch",
                                         String,
                                         queue_size=5)
        self.btree_sub = rospy.Subscriber("/behavior_switch", String,
                                          self.btree_cb)
        self.soma_pub = rospy.Publisher('/blender_api/set_soma_state',
                                        SomaState,
                                        queue_size=10)
        self.look_pub = rospy.Publisher('/blender_api/set_face_target',
                                        Target,
                                        queue_size=10)
        self.gaze_pub = rospy.Publisher('/blender_api/set_gaze_target',
                                        Target,
                                        queue_size=10)
        self.performance_runner = rospy.ServiceProxy(
            '/performances/run_full_performance', srv.RunByName)
        # Wholeshow starts with behavior enabled, unless set otherwise
        rospy.set_param("/behavior_enabled",
                        rospy.get_param("/behavior_enabled", True))
        # Start sleeping. Wait for Blender to load
        rospy.wait_for_service('/blender_api/set_param')
        rospy.wait_for_service('/performances/current')
        self.blender_param = rospy.ServiceProxy('/blender_api/set_param',
                                                SetParam)
        time.sleep(2)
        self.sleeping = rospy.get_param('start_sleeping', False)
        if self.sleeping:
            t = threading.Timer(1, self.to_sleeping)
            t.start()
        # Performance id as key and keyword array as value
        self.performances_keywords = {}
        # Parse on load.
        # TODO make sure we reload those once performances are saved.
        self.after_performance = False
        # Speech handler. Receives all speech input, and forwards to chatbot if its not a command input,
        #  or chat is enabled
        self.speech_sub = rospy.Subscriber('speech', ChatMessage,
                                           self.speech_cb)
        self.speech_pub = rospy.Publisher('chatbot_speech',
                                          ChatMessage,
                                          queue_size=10)
        # Sleep
        self.performance_events = rospy.Subscriber('/performances/events',
                                                   Event, self.performances_cb)
        # Dynamic reconfigure
        self.config = {}
        self.cfg_srv = Server(WholeshowConfig, self.config_cb)
        # Behavior was paused entering into state
        self.behavior_paused = False
        # Chatbot was paused entering the state
        self.chatbot_paused = False
        self.sleeping = rospy.get_param('start_sleeping', False)
        # Preferred speech source
        self.speech_provider = rospy.get_param("active_stt", 'cloudspeech')
        self.speech_provider_active = False
        rospy.Subscriber('{}/status'.format(self.speech_provider), Bool,
                         self.stt_status_cb)
コード例 #33
0
	def __init__(self, name):
		annotator.__init__(self, name)
		self.machine = Machine(model=self, states=SimpleFSA._states, initial='waiting')
		self.machine.add_transition(trigger='start_analysis', source='waiting', dest='analysing', after='_analyse')
		self.machine.add_transition('corrected', 'analysing', 'finished')
コード例 #34
0
 def __init__(self, top):
     self.top = top
     self.states = ['n1', {'name': 'n2', 'on_enter': self.print_msg}]
     Machine.__init__(self, states=self.states, initial='n1')
     self.add_transition(trigger='goto_n2', source='*', dest='n2')
コード例 #35
0
ファイル: test_reuse.py プロジェクト: wtgee/transitions
    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)
コード例 #36
0
class HFSA14(annotator):

	_states = [
		{'name': 'waiting', 'on_enter': '_reset_positions'},
		{'name': 'searching_for_first_spondeus', 'children': ['secondF', 'firstF', 'fourthF']},
		{'name': 'searching_for_second_spondeus', 'children': ['firstF', 'fourthF', 'thirdF']},
		{'name': 'searching_for_third_spondeus', 'children': ['fourthF', 'thirdF', 'fifthF']},
		{'name': 'no_spondeus_found', 'on_enter': '_make_spondeus'},
		{'name': 'found_three_spondees', 'on_enter': '_make_scansion'},
		{'name': 'fallback', 'on_enter': '_search_whole'},
		{'name': 'correction', 'on_enter': '_correct'},
		'success',
		'failure'
	]

	def __init__ (self, name):
		annotator.__init__(self, name)
		self.machine = Machine(model=self, states=HFSA14._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_firstF', 'searching_for_first_spondeus_fourthF', unless=[self._found_first], after='_search_fourth')
		self.machine.add_transition('search_spondeus', 'searching_for_first_spondeus_fourthF', 'no_spondeus_found', unless=[self._found_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', 'searching_for_second_spondeus_fourthF', unless=[self._found_second], after='_search_fourth')
		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_second_spondeus_thirdF', 'no_spondeus_found', unless=[self._found_second])
		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_first_spondeus_firstF', 'searching_for_second_spondeus_fourthF', conditions=[self._found_first], after='_search_fourth')
		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', 'searching_for_third_spondeus_fifthF', conditions=[self._found_second], after='_search_fifth')
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_fifthF', 'no_spondeus_found', unless=[self._found_third])
		self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_firstF', 'searching_for_third_spondeus_fourthF', conditions=[self._found_second], after='_search_fourth')
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_fourthF', 'searching_for_third_spondeus_thirdF', unless=[self._found_third], after='_search_third')
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_thirdF', 'searching_for_third_spondeus_fifthF', unless=[self._found_third], after='_search_fifth')
		self.machine.add_transition('search_spondeus', 'searching_for_second_spondeus_fourthF', 'searching_for_third_spondeus_thirdF', conditions=[self._found_second], after='_search_third')
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_fifthF', 'found_three_spondees', conditions=[self._found_third])
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_fourthF', 'found_three_spondees', conditions=[self._found_third])
		self.machine.add_transition('search_spondeus', 'searching_for_third_spondeus_thirdF', 'found_three_spondees', conditions=[self._found_third])
		self.machine.add_transition('search_spondeus', 'found_three_spondees', 'no_spondeus_found')
		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_three_spondees', 'success', conditions=[self._is_successful])
		self.machine.add_transition('verified', 'found_three_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 _search_second(self):
		third = self._search_long(3)
		fourth = self._search_long(4)
		fifth = self._search_long(5)
		if third and fourth:
			self.positions.append(3)
			self.positions.append(4)
			self._set_found()
		elif fourth and fifth:
			self.positions.append(4)
			self.positions.append(5)
			self._set_found()
		else:
			if third:
				self.positions.append(3)
			if fourth:
				self.positions.append(4)
			if fifth:
				self.positions.append(5)
		self.search_spondeus()

	def _search_first(self):
		first = self._search_long(1)
		second = self._search_long(2)
		if first and second:
			self.positions.append(1)
			self.positions.append(2)
			self._set_found()
		elif first:
			self.positions.append(1)
		elif second:
			self.positions.append(2)
		self.search_spondeus()
		
	def _search_fourth(self):
		eigth = self._search_long(8)
		ninth = self._search_long(9)
		tenth = self._search_long(10)
		if eigth and ninth:
			self.positions.append(8)
			self.positions.append(9)
			self._set_found()
		elif ninth and tenth:
			self.positions.append(9)
			self.positions.append(10)
			self._set_found()
		else:
			if eigth:
				self.positions.append(8)
			if ninth:
				self.positions.append(9)
			if tenth:
				self.positions.append(10)
		self.search_spondeus()
		
	def _search_third(self):
		sixth = self._search_long(6)
		seventh = self._search_long(7)
		eigth = self._search_long(8)
		if seventh and eigth:
			self.positions.append(7)
			self.positions.append(8)
			self._set_found()
		elif sixth and seventh:
			self.positions.append(6)
			self.positions.append(7)
			self._set_found()
		else:
			if sixth:
				self.positions.append(6)
			if seventh:
				self.positions.append(7)
			if eigth:
				self.positions.append(8)
		self.search_spondeus()
		
	def _search_fifth(self):
		eleventh = self._search_long(11)
		twelfth = self._search_long(12)
		if eleventh and twelfth:
			self.positions.append(11)
			self.positions.append(12)
			self._set_found()
		elif eleventh:
			self.positions.append(11)
		elif twelfth:
			self.positions.append(12)
		self.search_spondeus()

	def _make_scansion(self):
		for x in range(1,13):
			if x not in self.positions:
				self.questions.append(x)
		#nr. 30
		if 8 in self.questions and 9 in self.questions and 11 in self.questions and 12 in self.questions:
			self.verse.scansion = '-- -- -- -** -** -X'
			self._verify_output()
		#nr. 31
		elif 6 in self.questions and 7 in self.questions and 11 in self.questions and 12 in self.questions:
			self.verse.scansion = '-- -- -** -- -** -X'
			self._verify_output()
		#nr. 32
		elif 6 in self.questions and 7 in self.questions and 9 in self.questions and 10 in self.questions:
			self.verse.scansion = '-- -- -** -** -- -X'
			self._verify_output()
		#nr. 33
		elif 2 in self.questions and 3 in self.questions and 11 in self.questions and 12 in self.questions:
			self.verse.scansion = '-** -- -- -- -** -X'
			self._verify_output()
		#nr. 34
		elif 2 in self.questions and 3 in self.questions and 9 in self.questions and 10 in self.questions:
			self.verse.scansion = '-** -- -- -** -- -X'
			self._verify_output()
		#nr. 35
		elif 2 in self.questions and 3 in self.questions and 7 in self.questions and 8 in self.questions:
			self.verse.scansion = '-** -- -** -- -- -X'
			self._verify_output()
		#nr. 36
		elif 2 in self.questions and 3 in self.questions and 5 in self.questions and 6 in self.questions:
			self.verse.scansion = '-** -** -- -- -- -X'
			self._verify_output()
		#nr. 37
		elif 4 in self.questions and 5 in self.questions and 11 in self.questions and 12 in self.questions:
			self.verse.scansion = '-- -** -- -- -** -X'
			self._verify_output()
		#nr. 38
		elif 4 in self.questions and 5 in self.questions and 9 in self.questions and 10 in self.questions:
			self.verse.scansion = '-- -** -- -** -- -X'
			self._verify_output()
		#nr. 39
		elif 4 in self.questions and 5 in self.questions and 7 in self.questions and 8 in self.questions:
			self.verse.scansion = '-- -** -** -- -- -X'
			self._verify_output()
		else:
			self.search_spondeus()

	def _make_spondeus(self):
		annotator._make_spondeus(self, 12)
コード例 #37
0
ファイル: test_transitions.py プロジェクト: brettviren/zio
    ['walk', 'caffeinated_dithering', 'caffeinated_running'],
    ['relax', 'caffeinated', 'standing']
]

# states = ['standing', 'walking',
#           {'name': 'caffeinated', 'children':['dithering', 'running']}]
# transitions = [
#   ['walk', 'standing', 'walking'],
#   ['stop', 'walking', 'standing'],
#   ['drink', '*', '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)

machine.walk()  # we have to go faster
print(machine.state)

machine.stop()  # can't stop moving!
print(machine.state)

machine.relax()  # leave nested state
print(machine.state)  # phew, what a ride
コード例 #38
0
ファイル: test_reuse.py プロジェクト: malinoff/transitions
    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)