def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) machine_args = { arg: getattr(self.StateMachine, arg) for arg in dir(self.StateMachine) if not arg.startswith("_") } transitions = [ self.find_additional_args_for_transitions(trans_kwargs) for trans_kwargs in machine_args["transitions"] ] machine_args.update({ "transitions": transitions, "model": self, "initial": self.state }) self.machine = Machine(**machine_args)
def _init_states(self): self.transitions = Machine(states=Session.states, initial='new') self.transitions.add_transition(trigger='connect', source='new', dest='connected') self.transitions.add_transition(trigger='connect', source='disconnected', dest='connected') self.transitions.add_transition(trigger='disconnect', source='connected', dest='disconnected') self.transitions.add_transition(trigger='disconnect', source='new', dest='disconnected') self.transitions.add_transition(trigger='disconnect', source='disconnected', dest='disconnected')
def test_send_event_data_conditions(self): states = ['A', 'B', 'C', 'D'] s = Stuff() # First pass positional and keyword args directly to the condition m = Machine(model=s, states=states, initial='A', send_event=False) m.add_transition( trigger='advance', source='A', dest='B', conditions='this_fails_by_default') s.advance(boolean=True) self.assertEqual(s.state, 'B') # Now wrap arguments in an EventData instance m.send_event = True m.add_transition( trigger='advance', source='B', dest='C', conditions='extract_boolean') s.advance(boolean=False) self.assertEqual(s.state, 'B')
def __init__(self, map_graph, node_descriptors): self.machine = Machine( model=self, states=[str(this_node['id']) for this_node in map_graph['nodes']], transitions=map_graph['transitions'], ignore_invalid_triggers=True, initial=map_graph['initial']) """ Nodes is a list of dicts {'base_type': 'indoor', 'type': 'v/veranda', 'target': False, 'instance': 'v/veranda/ADE_train_00019501.jpg', 'id': (2, 1)} """ self.nodes = map_graph['nodes'] self.node_descriptors = node_descriptors
def __init__( self, symbol: str, hold_short_a: float = -0.5, hold_short_b: float = -0.8, hold_short_c: float = -1.0, ): """持仓对象 :param symbol: 标的代码 :param hold_short_a: 首次开空仓后的仓位 :param hold_short_b: 第一次加空后的仓位 :param hold_short_c: 第二次加空后的仓位 """ assert 0 >= hold_short_a >= hold_short_b >= hold_short_c >= -1.0 self.symbol = symbol self.pos_map = { "hold_money": 0, "hold_short_a": hold_short_a, "hold_short_b": hold_short_b, "hold_short_c": hold_short_c } self.states = list(self.pos_map.keys()) self.machine = Machine(model=self, states=self.states, initial='hold_money') self.machine.add_transition('short_open', 'hold_money', 'hold_short_a') self.machine.add_transition('short_add1', 'hold_short_a', 'hold_short_b') self.machine.add_transition('short_add2', 'hold_short_b', 'hold_short_c') self.machine.add_transition('short_reduce1', 'hold_short_c', 'hold_short_b') self.machine.add_transition('short_reduce2', ['hold_short_b', 'hold_short_c'], 'hold_short_a') self.machine.add_transition( 'short_exit', ['hold_short_a', 'hold_short_b', 'hold_short_c'], 'hold_money') self.operates = [] self.short_low = -1 # 持空仓期间出现的最低价 self.short_cost = -1 # 最近一次加空仓的成本 self.short_bid = -1 # 最近一次加空仓的1分钟Bar ID
def __init__(self): self.states = [ 'waiting4start', 'pullingBack', 'slackening', 'launching' ] self.transitions = [ { 'trigger': 'startOver', 'source': '*', 'dest': 'waiting4start', 'after': 'do_waiting4start' }, { 'trigger': 'beginPull', 'source': 'waiting4start', 'dest': 'pullingBack', 'after': 'do_pullingBack', 'conditions': 'olfactometer_says_go' }, { 'trigger': 'slacken', 'source': 'pullingBack', 'dest': 'slackening', 'after': 'do_slackening', 'conditions': 'not_struggling_anymore' }, { 'trigger': 'catchorlaunch', 'source': 'slackening', 'dest': 'pullingBack', 'after': 'do_pullingBack', 'conditions': 'animal_escaped' }, { 'trigger': 'catchorlaunch', 'source': 'slackening', 'dest': 'launching', 'after': 'do_launching', 'conditions': 'ok_to_launch' }, ] Machine(model=self, states=self.states, transitions=self.transitions, initial='waiting4start') self.startOver()
def __init__(self, name): self.name = name self.machine = Machine(model=self, states=Haley.states, initial='init', auto_transitions=False) self.machine.add_transition(trigger='startSetup', source='init', dest='setup') self.machine.add_transition(trigger='setupComplete', source='setup', dest='ready') self.machine.add_transition(trigger='startPressed', source='ready', dest='waitForGreen') self.machine.add_transition(trigger='greenlight', source='waitForGreen', dest='blindDrive') self.machine.add_transition(trigger='wallsDedected', source='blindDrive', dest='guidedDrive') self.machine.add_transition(trigger='wallsLost', source='guidedDrive', dest='turning', unless='hasTurned') self.machine.add_transition(trigger='wallsLost', source='guidedDrive', dest='buttonDrive', conditions='hasTurned') self.machine.add_transition(trigger='turnDone', source='turning', dest='blindDrive') self.machine.add_transition(trigger='buttonPressed', source='buttonDrive', dest='end')
def __init__(self, timer): super().__init__() self.timer = timer self.prev_state = None self.machine = Machine( model=self, states=TimerStateMachine.states, initial='stopped', name='TimerFSM', after_state_change='on_after_state_change') self.machine.add_transition( trigger='on_stop', source='*', dest='stopped', before='save_prev_state') self.machine.add_transition( trigger='on_pause', source=['running', 'alarmed'], dest='paused', before='save_prev_state') self.machine.add_transition( trigger='on_overflow', source=['running', 'alarmed'], dest='overflowed', before='save_prev_state') self.machine.add_transition( trigger='on_alarm', source='running', dest='alarmed', before='save_prev_state') self.machine.add_transition( trigger='on_start', source='alarmed', dest='running', conditions='is_cycling', before='save_prev_state') self.machine.add_transition( trigger='on_start', source='paused', dest='alarmed', conditions='prev_is_alarmed', before='save_prev_state') self.machine.add_transition( trigger='on_start', source='paused', dest='running', conditions='prev_is_running', before='save_prev_state') self.machine.add_transition( trigger='on_start', source='stopped', dest='running', before='save_prev_state')
def __init__(self, sic: BasicSICConnector): self.sic = sic self.action_runner = ActionRunner(self.sic) self.machine = Machine(model=self, states=ExampleRobot.states, initial='asleep') self.user_model = {} self.recognition_manager = { 'attempt_success': False, 'attempt_number': 0 } # Define transitions self.machine.add_transition(trigger='start', source='asleep', dest='awake', before='wake_up', after='introduce') self.machine.add_transition(trigger='introduce', source='awake', dest='introduced', before='introduction', after='get_name') self.machine.add_transition(trigger='get_name', source='introduced', dest='asked_name', before='ask_name', after='get_acquainted') self.machine.add_transition(trigger='get_acquainted', source='asked_name', dest='got_acquainted', conditions='has_name', before='get_acquainted_with', after='rest') self.machine.add_transition(trigger='get_acquainted', source='asked_name', dest='got_acquainted', unless='has_name', before='get_acquainted_without', after='rest') self.machine.add_transition(trigger='rest', source='*', dest='asleep', before='saying_goodbye')
def __init__( self, clock: Clock, transitions: List[List[object]], states: List[Enum], initial_state: Enum, object_id: str = None, ): """ Parameters ---------- clock : Clock Simulated clock transitions : list List of state transitions, e.g. "idling" to "moving_to" states : List[Enum] List of state names, e.g. "idling", "moving_to" initial_state : Enum Initial state object_id : str A unique id of an object """ self.id = object_id if self.id is None: self.id = uuid4().hex self.clock = clock self.created_at = clock.now self._state_machine = Machine( model=self, states=states, transitions=transitions, initial=initial_state, send_event=True, after_state_change="on_state_changed", ) self.logger = get_simobility_logger()
def __init__(self, name): # No anonymous superheroes on my watch! Every narcoleptic superhero gets # a name. Any name at all. SleepyMan. SlumberGirl. You get the idea. self.name = name # What have we accomplished today? self.kittens_rescued = 0 # Initialize the state machine self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep', send_event=True) # Add some transitions. We could also define these using a static list of # dictionaries, as we did with states above, and then pass the list to # the Machine initializer as the transitions= argument. # At some point, every superhero must rise and shine. self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out', after="waked") # Superheroes need to keep in shape. self.machine.add_transition('work_out', 'hanging out', 'hungry') # Those calories won't replenish themselves! self.machine.add_transition('eat', 'hungry', 'hanging out') # Superheroes are always on call. ALWAYS. But they're not always # dressed in work-appropriate clothing. self.machine.add_transition('distress_call', '*', 'saving the world', before='change_into_super_secret_costume') # When they get off work, they're all sweaty and disgusting. But before # they do anything else, they have to meticulously log their latest # escapades. Because the legal department says so. self.machine.add_transition('complete_mission', 'saving the world', 'sweaty', after='update_journal') # Sweat is a disorder that can be remedied with water. # Unless you've had a particularly long day, in which case... bed time! self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted']) self.machine.add_transition('clean_up', 'sweaty', 'hanging out') # Our NarcolepticSuperhero can fall asleep at pretty much any time. self.machine.add_transition('nap', '*', 'asleep')
def __init__(self): super(FSMDST, self).__init__() self.dialogue_state = default_state() self.dialogue_state["cur_domain"] = "餐馆" self.restaurant_states = list( self.dialogue_state["belief_state"]["餐馆"].keys()) self.restaurant_states.append("Request") self.machine = Machine(model=self, states=self.restaurant_states, initial="greet") self.dest2trigger = { "推荐菜": { "trigger": "inform_restaurant_dish", "callback": "set_recommend_dish", }, "评分": { "trigger": "inform_restaurant_rating", "callback": "set_rating" }, "人均消费": { "trigger": "inform_restaurant_avg_cost", "callback": "set_avg_cost", }, "周边酒店": { "trigger": "inform_restaurant_surrounding_hotel", "callback": "set_surrounding_hotel", }, "周边景点": { "trigger": "inform_restaurant_surrounding_attraction", "callback": "set_surrounding_attraction", }, "周边餐馆": { "trigger": "inform_restaurant_surrounding_restaurant", "callback": "set_surrounding_restaurant", }, } for slot, trigger in self.dest2trigger.items(): self.machine.add_transition( trigger=trigger["trigger"], source="*", dest=slot, before=trigger["callback"], )
def __init__(self, terrain_data: TerrainData) -> None: self.machine = Machine(model=self, states=Player.states, initial='idle') self.machine.add_transition(trigger='walk', source='idle', dest='walking', after='on_start_walk') self.machine.add_transition(trigger='stop', source='walking', dest='idle', after='on_stop') position = Vector2(terrain_data.start_x, terrain_data.start_y) self.transform = Transform(position, Direction.DOWN) self.terrain_data = terrain_data self.char_ctrl = CharacterController(terrain_data, self.transform) self.animator = PlayerAnimator(self.state, self.transform.direction)
def __check_machine(self, filename): """""" # multi-state-machine for one machine if filename in self.data_files: mts = self.data_files[filename] else: mts = MtsStateMachine(self.config) self.data_files[filename] = mts #mts = MTSState() # Initialize machine = Machine(mts, states=mts.states, send_event=True, transitions=mts.transitions, initial='init') return mts
def test_machine_finalize_exception(self): exception = ZeroDivisionError() def always_raises(event): raise exception def finalize_callback(event): self.assertEqual(event.error, exception) m = Machine(states=['A', 'B'], send_event=True, initial='A', before_state_change=always_raises, finalize_event=finalize_callback) with self.assertRaises(ZeroDivisionError): m.to_B()
def __init__(self, head, listener): self.machine = Machine(model=self, states=PenteFSM.states, transitions=PenteFSM.transitions, initial='startup', auto_transitions=True) self.command = self.nullCmd self.head = head last_seen = listener.getLatestCommonTime('handoff_point', 'base') self.originPoint = listener.getTransform('handoff_point', 'base', last_seen) last_seen = listener.getLatestCommonTime( 'dropoff_point', 'base', ) self.dropoffPoint = listener.getTransform('dropoff_point', 'base', last_seen)
def __init__(self, board: Board = None, verbose: bool = True, buffer: bool = True): # an agent maintains an up-to-date board, # the current state of the agent, # and the current turn. self.board: Board = Board() if not board else board self.machine = Machine(model=self, states=AgentState, transitions=Agent.TRANSITIONS, initial=AgentState.INIT) self.side: Optional[Side] = None self.action: Optional[Action] = None self.verbose: bool = verbose self.buffer: bool = buffer self.action_buffer: List[Action] = list() self.reward_buffer: List[float] = list()
def __init__(self, name): self.name = name self.node_situation = NodeSituation() self.machine = Machine( model=self, states=TaskSituationType, initial=TaskSituationType.Initial, after_state_change=self.change_node_situation_type, ) self._current_cycle = { StatusChangeType.Submit: None, StatusChangeType.Initial: None, StatusChangeType.Complete: None, StatusChangeType.Abort: None, } self._initial_transitions()
def test_ordered_transition_callback(self): class Model: def __init__(self): self.flag = False def make_true(self): self.flag = True model = Model() states = ['beginning', 'middle', 'end'] transits = [None, None, 'make_true'] m = Machine(model, states, initial='beginning') m.add_ordered_transitions(before=transits) model.next_state() self.assertFalse(model.flag) model.next_state() model.next_state() self.assertTrue(model.flag)
def __init__(self, name='miner', capacity=5, qty=0): self.name = name self.capacity = capacity self.qty = qty self.count = 0 self.runningTransitions = False self.machine = Machine(model=self, states=Miner.states, transitions=Miner.transitions, initial=Miner.initial, auto_transitions=False) for state in Miner.states: on_exit = getattr(self.machine, 'on_exit_' + state) on_exit('stopRunningTransitions') print('stopRunningTransitions() added to', state)
def __init__(self, config_path, **kwargs): super(MarketServiceAgent, self).__init__(**kwargs) config = utils.load_config(config_path) self.agent_name = config.get('agent_name', 'MixMarketService') self.market_period = int(config.get('market_period', 300)) self.reservation_delay = int(config.get('reservation_delay', 0)) self.offer_delay = int(config.get('offer_delay', 120)) self.verbose_logging = int(config.get('verbose_logging', True)) self.director = None # This can be periodic or event_driven self.market_type = config.get("market_type", "event_driven") if self.market_type not in ["periodic", "event_driven"]: self.market_type = "event_driven" self.state_machine = Machine(model=self, states=MarketServiceAgent.states, transitions= MarketServiceAgent.transitions, initial=INITIAL_WAIT) self.market_list = MarketList(self.vip.pubsub.publish, self.verbose_logging)
def test_dynamic_model_state_attribute(self): class Model: def __init__(self): self.status = None self.state = 'some_value' m = Machine(Model(), states=['A', 'B'], initial='A', model_attribute='status') self.assertEqual(m.model.status, 'A') self.assertEqual(m.model.state, 'some_value') m.add_transition('move', 'A', 'B') m.model.move() self.assertEqual(m.model.status, 'B') self.assertEqual(m.model.state, 'some_value')
def test_state_and_transition_with_underscore(self): m = Machine(Stuff(), states=['_A_', '_B_', '_C_'], initial='_A_') m.add_transition('_move_', '_A_', '_B_', prepare='increase_level') m.add_transition('_after_', '_B_', '_C_', prepare='increase_level') m.add_transition('_on_exit_', '_C_', '_A_', prepare='increase_level', conditions='this_fails') m.model._move_() self.assertEquals(m.model.state, '_B_') self.assertEquals(m.model.level, 2) m.model._after_() self.assertEquals(m.model.state, '_C_') self.assertEquals(m.model.level, 3) # State does not advance, but increase_level still runs m.model._on_exit_() self.assertEquals(m.model.state, '_C_') self.assertEquals(m.model.level, 4)
def test_string_trigger(self): def return_value(value): return value class Model: def trigger(self, value): return value self.stuff.machine.add_transition('do', '*', 'C') self.stuff.trigger('do') self.assertTrue(self.stuff.is_C()) self.stuff.machine.add_transition('maybe', 'C', 'A', conditions=return_value) self.assertFalse(self.stuff.trigger('maybe', value=False)) self.assertTrue(self.stuff.trigger('maybe', value=True)) self.assertTrue(self.stuff.is_A()) with self.assertRaises(AttributeError): self.stuff.trigger('not_available') with self.assertRaises(MachineError): self.stuff.trigger('maybe') model = Model() m = Machine(model=model) self.assertEqual(model.trigger(5), 5) def raise_key_error(): raise KeyError self.stuff.machine.add_transition('do_raise_keyerror', '*', 'C', before=raise_key_error) with self.assertRaises(KeyError): self.stuff.trigger('do_raise_keyerror') self.stuff.machine.get_model_state( self.stuff).ignore_invalid_triggers = True self.stuff.trigger('should_not_raise_anything') self.stuff.trigger('to_A') self.assertTrue(self.stuff.is_A()) self.stuff.machine.ignore_invalid_triggers = True self.stuff.trigger('should_not_raise_anything')
def __init__(self, api: Api): super().__init__() # Messenger api instance self.api = api # Transition machine instance self.machine = Machine( model=self, states=Pizza.states, initial='start', transitions=Pizza.transitions, before_state_change=lambda event: self.logger.info(f'Change state to: \"{event.state.value}\"'), send_event=True # Encapsulate all callback arguments in Event object ) # Simple order info self.order = { 'size': 'большую', # Default 'payment': 'наличкой', # Default } # Simple pizza sizes validation rules self.pizza_size = { 'большую': r'больш[уюаяой]{2,}', 'маленькую': r'маленьк[уюаяой]{2,}' } # Simple payment method validation rules self.payment_methods = { 'наличкой': r'наличк[уаойе]{1,2}', 'картой': r'карт[ыуаойе]{1,2}' } # Simple confirmation words validation rules self.confirmation_words = { 'yes': ['Да', 'Подтверждаю', 'Согласен'], 'no': ['Нет', 'Не', 'Отказываюсь', 'Не согласен'] } # Signal words for intent exit self.cancel_words = [ 'Выход', 'Конец', 'Отстань' ]
def __init__(self, market_name, participant, publish, verbose_logging=True): self.reservations = ReservationManager() self.offers = OfferManager() self.market_name = market_name self.publish = publish self.verbose_logging = verbose_logging self.price = None _log.debug("Initializing Market: {} {} verbose logging is {}.".format( self.market_name, participant.buyer_seller, self.verbose_logging)) self.state_machine = Machine(model=self, states=Market.states, transitions=Market.transitions, initial=ACCEPT_RESERVATIONS) self.make_reservation(participant)
def test_init_machine_with_hella_arguments(self): states = [ State('State1'), 'State2', { 'name': 'State3', 'on_enter': 'hello_world' } ] transitions = [{ 'trigger': 'advance', 'source': 'State2', 'dest': 'State3' }] s = Stuff() m = Machine(model=s, states=states, transitions=transitions, initial='State2') s.advance() self.assertEqual(s.message, 'Hello World!')
def __init__(self, s): # ':' ---> __ # '=' ---> ___ self.machine = Machine(model=self, states=Scanner.states, initial='START') self.machine.add_transition('digit', 'START', 'INNUM') self.machine.add_transition('letter', 'START', 'INID') self.machine.add_transition('__', 'START', 'INASSIGN') self.machine.add_transition('other', 'START', 'DONE') self.machine.add_transition('digit', 'INNUM', 'INNUM') self.machine.add_transition('other', 'INNUM', 'DONE') self.machine.add_transition('letter', 'INID', 'INID') self.machine.add_transition('other', 'INID', 'DONE') self.machine.add_transition('___', 'INASSIGN', 'DONE') self.machine.add_transition('other', 'INASSIGN', 'DONE') self.input_string = s self.tokens = {} # final output dictionary. self.previous_state = None # previous state in state machine.
def test_send_event_data(self): states = ['A', 'B', 'C', 'D'] s = Stuff() # First pass positional and keyword args directly to the callback m = Machine(model=s, states=states, initial='A', send_event=False) m.add_transition(trigger='advance', source='A', dest='B', before='set_message') s.advance(message='Hallo. My name is Inigo Montoya.') self.assertTrue(s.message.startswith('Hallo.')) # Now wrap arguments in an EventData instance m.send_event = True m.add_transition(trigger='advance', source='B', dest='C', before='extract_message') s.advance(message='You killed my father. Prepare to die.') self.assertTrue(s.message.startswith('You'))
def test_callback_identification(self): m = Machine(Stuff(), states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A') m.add_transition('transition', 'A', 'B', before='increase_level') m.add_transition('after', 'B', 'C', before='increase_level') m.add_transition('on_exit_A', 'C', 'D', before='increase_level', conditions='this_fails') m.add_transition('check', 'C', 'E', before='increase_level') m.add_transition('prepare', 'E', 'F', before='increase_level') m.add_transition('before', 'F', 'A', before='increase_level') m.before_transition('increase_level') m.before_after('increase_level') m.before_on_exit_A('increase_level') m.after_check('increase_level') m.before_prepare('increase_level') m.before_before('increase_level') m.model.transition() self.assertEquals(m.model.state, 'B') self.assertEquals(m.model.level, 3) m.model.after() self.assertEquals(m.model.state, 'C') self.assertEquals(m.model.level, 5) m.model.on_exit_A() self.assertEquals(m.model.state, 'C') self.assertEquals(m.model.level, 5) m.model.check() self.assertEquals(m.model.state, 'E') self.assertEquals(m.model.level, 7) m.model.prepare() self.assertEquals(m.model.state, 'F') self.assertEquals(m.model.level, 9) m.model.before() self.assertEquals(m.model.state, 'A') self.assertEquals(m.model.level, 11) # An invalid transition shouldn't execute the callback with self.assertRaises(MachineError): m.model.on_exit_A()