def test_execute_transition_not_found(self): fsm = FSM("off") fsm.add_transition("play", "off", "music", "on") self.assertRaises(Exception, fsm.execute, "stop") self.assertIsNone(fsm.action) self.assertIsNone(fsm.prev_state) self.assertEqual("off", fsm.current_state)
def __init__(self): self.keypad = Keypad() self.fsm = FSM(self) self.ledboard = LedBoard() self.override_signal = None self.bulbNumber = "" #which bulb to be lit, LID self.ledTime = "" #duration of lit LED, Ldur
def __init__(self, initial_state): self.FSM = FSM(initial_state) self.FSM.add_transition("Antelope", "Hungry", "Eat", "Fed") self.FSM.add_transition("Antelope", "Fed", "Sleep", "Hungry") self.FSM.add_transition("Hunter", "Hungry", "Run away") self.FSM.add_transition("Hunter", "Fed", "Run away", "Hungry") self.FSM.add_transition("Tree", "Hungry", "Sleep") self.FSM.add_transition("Tree", "Fed", "Look", "Hungry")
def main(): print("Test program") task_1_config = { "fnc": read_uart, "args": (), "periodic": True, "period": 0.1, "trace_dependent": False, "entry_states": ("init", "griffin_turning_on", "griffin_started"), "end_state": "no_change" } task_2_config = { "fnc": griffin_on, "args": (), "periodic": False, "execution_time": 2, "trace_dependent": False, "entry_states": ("init"), "end_state": "griffin_turning_on" } task_3_config = { "fnc": check_for_starting, "args": (), "periodic": True, "period": 0.5, "trace_dependent": True, "entry_states": ("griffin_turning_on"), "end_state": "return_value" } task_4_config = { "fnc": change_state, "args": (), "periodic": False, "execution_time": 10, "entry_states": ("init", "second_state"), "end_state": "return_value" } task_when_second_state_config = { "fnc": foo, "args": ("Now in second_state", ), "periodic": False, "execution_time": 0, "entry_states": ("second_state"), "end_state": "second_state" } tasks = { "task_1": task_1_config, "task_2": task_2_config, "task_3": task_3_config } trace = "" fsm = FSM(tasks, trace) while True: fsm.run()
def __init__(self, inputComponents, velocityComponents): Observer.__init__(self) Publisher.__init__(self) self.inputComponents = inputComponents self.velocityComponents = velocityComponents self.inputMapper = InputMapper() self.fsm = FSM() FSMGraphFactory(self.fsm, GraphIDs.Moving)
def term(self): if self.token() not in {"|",")",None}: fsm = self.factor() else: fsm = FSM("") while self.token() not in {"|",")",None}: fsm.concatenate(self.factor()) return fsm
def term(self): if self.token() not in {"|", ")", None}: fsm = self.factor() else: fsm = FSM("") while self.token() not in {"|", ")", None}: fsm.concatenate(self.factor()) return fsm
def __init__(self): self._refbox_state_to_str = lambda state: refbox_state_to_str[state] self._refbox_states_to_str = lambda list_of_states: map(self._refbox_state_to_str , list_of_states) self._bmbox_state_to_str = lambda state: bmbox_state_to_str[state] self._bmbox_states_to_str = lambda list_of_states: map(self._bmbox_state_to_str , list_of_states) self.__current_goal = None self.__current_manual_operation = None self.__current_referee_score = None self.__fsm = FSM( bmbox_state_to_str, ( (BmBoxState.WAITING_CLIENT, BmBoxState.END), # allowed transitions from BmBoxState.START (BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_CLIENT (BmBoxState.WAITING_MANUAL_OPERATION, BmBoxState.TRANSMITTING_GOAL, BmBoxState.TRANSMITTING_SCORE, BmBoxState.END), # allowed transitions from BmBoxState.READY (BmBoxState.COMPLETED_MANUAL_OPERATION, BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_MANUAL_OPERATION (BmBoxState.TRANSMITTING_GOAL, BmBoxState.WAITING_MANUAL_OPERATION, BmBoxState.END), # allowed transitions from BmBoxState.COMPLETED_MANUAL_OPERATION (BmBoxState.EXECUTING_GOAL, BmBoxState.END), # allowed transitions from BmBoxState.TRANSMITTING_GOAL (BmBoxState.WAITING_RESULT, BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.EXECUTING_GOAL (BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_RESULT (BmBoxState.END, ), # allowed transitions from BmBoxState.TRANSMITTING_SCORE (BmBoxState.END, ), # allowed transitions from BmBoxState.END ), BmBoxState.START ) self.__exception_states = [RefBoxState.STOP, RefBoxState.ERROR, RefBoxState.GLOBAL_TIMEOUT] self.__refbox_state = RefBoxState() self.__status = SystemStatus() self.__status.status = SystemStatus.NORMAL self.__state_pub = rospy.Publisher("bmbox/bmbox_state", BmBoxState, queue_size=10) self.__status_pub = rospy.Publisher("rsbb_system_status/bmbox", SystemStatus, queue_size=10) self.__refbox_state_observer = StateObserver(self.__exception_states, self.__refbox_state, refbox_state_to_str) self.__pub_thread = Thread(name="pub_thread", target=self.__pub_thread) self.__pub_thread.start() self._start_benchmark_server = rospy.Service("bmbox/start_benchmark", StartBenchmark, self.__start_benchmark_callback) self._manual_operation_complete_server = rospy.Service("bmbox/manual_operation_complete", ManualOperationComplete, self.__manual_operation_complete_callback) self._goal_started_server = rospy.Service("bmbox/goal_execution_started", GoalStarted, self.__goal_started_callback) self._goal_complete_server = rospy.Service("bmbox/goal_complete", GoalComplete, self.__goal_complete_callback) self._goal_complete_server = rospy.Service("bmbox/referee_score", RefereeScore, self.__referee_score_callback) self._stop_benchmark_server = rospy.Service("bmbox/stop_benchmark", StopBenchmark, self.__stop_benchmark_callback) ### TEST self.tmp = 0
class InputSystem(Observer, Publisher): """ This system takes raw inpout from the keyboard and translates into actions and states held in an instance of "InputMapper". All code to do so is held within the InputMapper. """ def __init__(self, inputComponents, velocityComponents): Observer.__init__(self) Publisher.__init__(self) self.inputComponents = inputComponents self.velocityComponents = velocityComponents self.inputMapper = InputMapper() self.fsm = FSM() FSMGraphFactory(self.fsm, GraphIDs.Moving) def handleInput(self): mappedInput = self.inputMapper.MapInput() for ID in self.inputComponents: if self.fsm.run(mappedInput, inputComponent=self.inputComponents[ID], velocityComponent=self.velocityComponents[ID]): inputEvent = Event() inputEvent.entityID = ID self.fsm.transitionFunctions.process(inputEvent) self.publishEvent(inputEvent)
def p_atom( p ) : '''atom : LPAREN expr RPAREN | SYMBOL''' if len(p) == 4: p[0] = p[2] else: p[0] = FSM(p[1])
def p_term( p ) : '''term : factor term | ''' if len(p) == 3: p[1].concatenate(p[2]) p[0] = p[1] else: p[0] = FSM("")
def start(bot, update): # inserts new user to database (if not exist) and sets initial state to 'initial' state = database_manager.get_user_state(update.message.chat.id) if state != 'initial': database_manager.set_user_state(update.message.chat.id, 'initial') fsm = FSM('initial') fsm.machine.start(update) database_manager.set_user_state(update.message.chat.id, fsm.machine.state)
def main(): parser = argparse.ArgumentParser("Homework 1 dialog manager system") parser.add_argument("-v", "--verbose", action="count", default=0) parser.add_argument("-s", "--system", choices=["FSM"]) parser.add_argument("-l", "--NLU", default="Default") parser.add_argument("-g", "--NLG", default="Default") args = parser.parse_args() system = args.system NLU = args.NLU NLG = args.NLG print("NLU = {}, system = {}, NLG = {}".format(NLU, system, NLG)) NLUModule = None DMModule = None NLGModule = None if NLU == "Default": NLUModule = NLUDefault() if NLG == "Default": NLGModule = NLGDefault() if system == "FSM": DMModule = FSM(NLUModule, NLGModule) else: print("{} not implemented".format(system)) return print("Welcome to the HW2 Dialog System") while True: inputStr = input("> ") if inputStr == "Quit": break try: outputStr = DMModule.execute(inputStr) except Exception as e: print(e) break print(outputStr)
def index(comm): global command items = comm.split(',') orientation = items[0] speed = int(items[1]) command = FSM(orientation, speed) print command return template('<b>command: {{comm}} length queue: {{length}}</b>', comm=comm, length=len(comm))
def __init__(self, options, args): self.TestSuite = False # used by pmt nruns logic self.module = dict() # dict of modules keyed by name self.mp = dict() # dict of model programs keyed by same module name # Populate self.module and self.mp from modules named in command line args # Models that users write are just modules, not classes (types) # so we find out what type to wrap each one in # by checking for one of each type's required attributes using hasattr for mname in args: # args is list of module name self.module[mname] = __import__(mname) if hasattr(self.module[mname], 'graph'): self.mp[mname] = FSM(self.module[mname], options.exclude, options.action) # for backwards compatibility we accept all of these test_suite variants elif (hasattr(self.module[mname], 'testSuite') or hasattr(self.module[mname], 'testsuite') or hasattr(self.module[mname], 'test_suite')): self.mp[mname] = TestSuite(self.module[mname], options.exclude, options.action) self.TestSuite = True # used by pmt nruns logic elif self.module[mname].__doc__.strip().upper().startswith( 'PYMODEL CONFIG'): pass # configuration module, merely importing it did all the work else: # got this far, should be a ModelProgram -- if not, crash self.mp[mname] = ModelProgram(self.module[mname], options.exclude, options.action) # Now that all modules have been imported and executed their __init__ # do a postprocessing pass over all model objects # to process metadata that might be affected by configuration modules for mp in self.mp.values(): mp.post_init() # set of all anames in all model programs - the vocabulary of the product self.anames = set().union( * [set([a.__name__ for a in mp.actions]) for mp in self.mp.values()]) # print 'anames %s' % self.anames # DEBUG # set of anames of all observable actions in all model programs # observables obtain arg values from the environment, not parameter gen. self.observables = set().union(*[ set([a.__name__ for a in mp.module.observables]) for mp in self.mp.values() ]) # FSM and TestSuite must have .observables # print 'observables %s' % self.observables # DEBUG # dict from aname to set of all m where aname is in vocabulary self.vocabularies = \ dict([(aname, set([m for m in self.mp if aname in [a.__name__ for a in self.mp[m].actions]])) for aname in self.anames])
def test_execute_transition_found(self): fsm = FSM("off") fsm.add_transition("play", "off", "music", "on") fsm.execute("play") self.assertEqual("music", fsm.action) self.assertEqual("off", fsm.prev_state) self.assertEqual("on", fsm.current_state)
def __init__(self, initerestring, events): #initial spec ERE to start from self.erestring = initerestring #all events relating to ERE self.events = events #dictionary of quick lookup terms self.t = r"\(|\)|\~|\&|\||\*|\+|epsilon|\^|empty|\w+" self.initERE = self.genERE() self.symbolist = [Symbol.stringToRef[i] for i in self.events] self.fsm = FSM.getFSM(self.initERE, self.symbolist) self.currstate = self.initERE self.violated = False self.reported = False self.state_string = "s0"
def fsm_from_expression(exp): fsm_stack = [] for char in exp: if char in SIGMA or char == '1': fsm = FSM() fsm_stack.append(fsm.create(char)) elif char == '.': second_fsm = fsm_stack.pop() first_fsm = fsm_stack.pop() fsm_stack.append(concat(first_fsm, second_fsm)) elif char == '+': first_fsm = fsm_stack.pop() second_fsm = fsm_stack.pop() fsm_stack.append(add(first_fsm, second_fsm)) elif char == '*': fsm = fsm_stack.pop() fsm_stack.append(iteration(fsm)) if len(fsm_stack) != 1: raise IndexError return fsm_stack[0]
def atom(self): if self.token() == "(": self.next() fsm = self.expr() if self.token() == ")": self.next() else: raise ValueError elif self.token() not in {")", "|", "*"}: fsm = FSM(self.token()) self.next() else: raise ValueError return fsm
def main(): trans = MyTransitions() fsm = {} for n in range(0, 4): fsm[n] = FSM([ ("Sova", "Äta", 'hungrig', lambda x: x == trans.sova('hungrig')), ("Sova", "Umgås", 'glad', lambda x: x == trans.sova('glad')), ("Sova", "Jobba", 'tjäna', lambda x: x == trans.sova('tjäna')), ("Sova", "Dricka", 'törstig', lambda x: x == trans.sova('törstig')), ("Äta", "Sova", 'trött', lambda x: x == trans.ata('trött')), ("Äta", "Jobba", 'tjäna', lambda x: x == trans.ata('tjäna')), ("Äta", "Umgås", 'glad', lambda x: x == trans.ata('glad')), ("Umgås", "Äta", 'hungrig', lambda x: x == trans.umgas('hungrig')), ("Umgås", "Dricka", 'törstig', lambda x: x == trans.umgas('törstig')), ("Umgås", "Sova", 'trött', lambda x: x == trans.umgas('trött')), ("Jobba", "Sova", 'trött', lambda x: x == trans.jobba('trött')), ("Jobba", "Äta", 'hungrig', lambda x: x == trans.jobba('hungrig')), ("Jobba", "Dricka", 'törstig', lambda x: x == trans.jobba('törstig')), ("Jobba", "Jobba", 'tjäna', lambda x: x == trans.jobba('tjäna')), ("Jobba", "Handla", 'köpa', lambda x: x == trans.jobba('köpa')), ("Handla", "Äta", 'hungrig', lambda x: x == trans.handla('hungrig')), ("Handla", "Umgås", 'glad', lambda x: x == trans.handla('glad')), ("Handla", "Jobba", 'tjäna', lambda x: x == trans.handla('tjäna')), ("Dricka", "Sova", 'trött', lambda x: x == trans.dricka('trött')), ("Dricka", "Jobba", 'tjäna', lambda x: x == trans.dricka('tjäna')), ("Dricka", "Umgås", 'glad', lambda x: x == trans.dricka('glad')), ("Dricka", "Handla", 'köpa', lambda x: x == trans.dricka('köpa')), ("Dricka", "Äta", 'hungrig', lambda x: x == trans.dricka('hungrig')) ]) name = 'actor' + str(n) actors[name] = Actor(fsm[n], name, dispatcher) dispatcher.addClients(actors) printCommands() cmd = input() while (not cmd == 'quit'): doCommand(cmd) cmd = input()
def create(**actions): S_init = STATE('init') S_error = STATE('error') S_state = STATE('state', enter=actions['state']) S_event = STATE('event', enter=actions['event']) S_init.set_events([ EVENT('state', [], S_state), ]) S_error.set_events([]) S_state.set_events([ EVENT('state', [], S_state), EVENT('enter', [actions['enter']]), EVENT('exit', [actions['exit']]), EVENT('event', [], S_event), EVENT('error', [], S_error), ]) S_event.set_events([ EVENT('action', [actions['action']]), EVENT('state', [], S_state), EVENT('event', [], S_event), EVENT('error', [], S_error), ]) return FSM([S_init, S_error, S_state, S_event])
class RefBoxComm: def __init__(self): self._refbox_state_to_str = lambda state: refbox_state_to_str[state] self._refbox_states_to_str = lambda list_of_states: map(self._refbox_state_to_str , list_of_states) self._bmbox_state_to_str = lambda state: bmbox_state_to_str[state] self._bmbox_states_to_str = lambda list_of_states: map(self._bmbox_state_to_str , list_of_states) self.__current_goal = None self.__current_manual_operation = None self.__current_referee_score = None self.__fsm = FSM( bmbox_state_to_str, ( (BmBoxState.WAITING_CLIENT, BmBoxState.END), # allowed transitions from BmBoxState.START (BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_CLIENT (BmBoxState.WAITING_MANUAL_OPERATION, BmBoxState.TRANSMITTING_GOAL, BmBoxState.TRANSMITTING_SCORE, BmBoxState.END), # allowed transitions from BmBoxState.READY (BmBoxState.COMPLETED_MANUAL_OPERATION, BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_MANUAL_OPERATION (BmBoxState.TRANSMITTING_GOAL, BmBoxState.WAITING_MANUAL_OPERATION, BmBoxState.END), # allowed transitions from BmBoxState.COMPLETED_MANUAL_OPERATION (BmBoxState.EXECUTING_GOAL, BmBoxState.END), # allowed transitions from BmBoxState.TRANSMITTING_GOAL (BmBoxState.WAITING_RESULT, BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.EXECUTING_GOAL (BmBoxState.READY, BmBoxState.END), # allowed transitions from BmBoxState.WAITING_RESULT (BmBoxState.END, ), # allowed transitions from BmBoxState.TRANSMITTING_SCORE (BmBoxState.END, ), # allowed transitions from BmBoxState.END ), BmBoxState.START ) self.__exception_states = [RefBoxState.STOP, RefBoxState.ERROR, RefBoxState.GLOBAL_TIMEOUT] self.__refbox_state = RefBoxState() self.__status = SystemStatus() self.__status.status = SystemStatus.NORMAL self.__state_pub = rospy.Publisher("bmbox/bmbox_state", BmBoxState, queue_size=10) self.__status_pub = rospy.Publisher("rsbb_system_status/bmbox", SystemStatus, queue_size=10) self.__refbox_state_observer = StateObserver(self.__exception_states, self.__refbox_state, refbox_state_to_str) self.__pub_thread = Thread(name="pub_thread", target=self.__pub_thread) self.__pub_thread.start() self._start_benchmark_server = rospy.Service("bmbox/start_benchmark", StartBenchmark, self.__start_benchmark_callback) self._manual_operation_complete_server = rospy.Service("bmbox/manual_operation_complete", ManualOperationComplete, self.__manual_operation_complete_callback) self._goal_started_server = rospy.Service("bmbox/goal_execution_started", GoalStarted, self.__goal_started_callback) self._goal_complete_server = rospy.Service("bmbox/goal_complete", GoalComplete, self.__goal_complete_callback) self._goal_complete_server = rospy.Service("bmbox/referee_score", RefereeScore, self.__referee_score_callback) self._stop_benchmark_server = rospy.Service("bmbox/stop_benchmark", StopBenchmark, self.__stop_benchmark_callback) ### TEST self.tmp = 0 def __pub_thread(self): r = rospy.Rate(STATE_UPDATE_RATE) while not rospy.is_shutdown(): self.__state_pub.publish(self.__fsm.state(), self.__fsm.payload()) self.__publish_system_status("executing") r.sleep() self.__state_pub.unregister() def __publish_system_status(self, d = ""): self.__status.header.stamp = rospy.Time.now() self.__status.status_description = d self.__status_pub.publish(self.__status) def __update_refbox_state(self, refbox_state): self.__refbox_state = refbox_state self.__refbox_state_observer.update(refbox_state) print "\n\nbenchmark_state: %s\ngoal_execution_state: %s\nmanual_operation_state: %s\n" % (self._refbox_state_to_str(self.__refbox_state.benchmark_state),\ self._refbox_state_to_str(self.__refbox_state.goal_execution_state),\ self._refbox_state_to_str(self.__refbox_state.manual_operation_state)) def __start_benchmark_callback(self, request): rospy.loginfo("start_benchmark_callback") if not self.is_benchmark_running(): rospy.loginfo("start_benchmark_callback: benchmark not running") if not self.check_preconditions(bmbox_states=[BmBoxState.WAITING_CLIENT, BmBoxState.END], log_function = rospy.logerr): rospy.logwarn("start_benchmark_callback: inconsistent states or benchmark not running") self.__update_refbox_state(request.refbox_state) return StartBenchmarkResponse(True) def __goal_started_callback(self, request): rospy.loginfo("goal_started_callback") ### TEST # if self.tmp < 5: # self.tmp += 1 # print "TEST __goal_started_callback: return GoalStartedResponse(False)" # return GoalStartedResponse(False) if not self.is_benchmark_running(): rospy.loginfo("goal_started_callback: benchmark not running") if self.__current_goal == None: rospy.logerr("goal_started_callback: cannot accept goal execution started event. No goal execution is pending") self.__update_refbox_state(request.refbox_state) return GoalStartedResponse(False) if not self.check_preconditions(bmbox_states=[BmBoxState.TRANSMITTING_GOAL, BmBoxState.END], log_function = rospy.logerr): rospy.logwarn("goal_started_callback: inconsistent states or benchmark not running") self.__update_refbox_state(request.refbox_state) return GoalStartedResponse(True) def __goal_complete_callback(self, request): rospy.loginfo("goal_complete_callback") ### TEST # if self.tmp < 5 and request.refbox_state.benchmark_state == RefBoxState.GLOBAL_TIMEOUT: # self.tmp += 1 # print "TEST __goal_complete_callback (GLOBAL_TIMEOUT): return GoalCompleteResponse(False)" # return GoalCompleteResponse(False) if not self.is_benchmark_running(): rospy.loginfo("goal_complete_callback: benchmark not running") if self.__current_goal == None: rospy.logerr("goal_complete_callback: cannot accept goal complete event. No goal execution is pending") self.__update_refbox_state(request.refbox_state) return GoalCompleteResponse(False) else: if request.goal_timeout: self.__current_goal.set_has_timed_out() else: self.__current_goal.set_result_string(request.goal_result) if not self.check_preconditions(bmbox_states=[BmBoxState.TRANSMITTING_GOAL, BmBoxState.EXECUTING_GOAL, BmBoxState.WAITING_RESULT, BmBoxState.END], log_function = rospy.logerr): rospy.logwarn("goal_complete_callback: inconsistent states or benchmark not running") self.__update_refbox_state(request.refbox_state) return GoalCompleteResponse(True) def __referee_score_callback(self, request): rospy.loginfo("referee_score_callback") try: self.__current_referee_score = yaml.load(request.score) self.save_and_publish_score() except yaml.YAMLError as e: rospy.logerr("referee_score_callback: YAMLError while parsing refere score yaml string\n%s"%e) return RefereeScoreResponse(True) def __manual_operation_complete_callback(self, request): rospy.loginfo("manual_operation_complete_callback") ### TEST # if self.tmp > 5: # self.tmp += 1 # print "TEST __manual_operation_complete_callback: return ManualOperationCompleteResponse(False)" # return ManualOperationCompleteResponse(False) if not self.is_benchmark_running(): rospy.loginfo("manual_operation_complete_callback: benchmark not running") if self.__current_manual_operation == None: rospy.logerr("manual_operation_complete_callback: cannot accept manual operation result. No manual operation is pending") self.__update_refbox_state(request.refbox_state) return ManualOperationCompleteResponse(False) else: self.__current_manual_operation.set_result(request.manual_operation_result) if not self.check_preconditions(bmbox_states=[BmBoxState.WAITING_MANUAL_OPERATION, BmBoxState.END], log_function = rospy.logerr): rospy.logwarn("manual_operation_complete_callback: inconsistent states or benchmark not running") self.__update_refbox_state(request.refbox_state) return ManualOperationCompleteResponse(True) def __stop_benchmark_callback(self, request): rospy.loginfo("stop_benchmark_callback") self.__update_refbox_state(request.refbox_state) return StopBenchmarkResponse(True) def _wait_refbox_connection(self): rospy.logdebug("RefBoxComm._wait_refbox_connection()") if not self.is_benchmark_running(): rospy.loginfo("wait_refbox_connection: benchmark not running") if not self.check_preconditions(bmbox_states=[BmBoxState.START, BmBoxState.END], log_function = rospy.logerr): rospy.logerr("_wait_refbox_connection: can not execute request") return self.__fsm.update(BmBoxState.WAITING_CLIENT) # woken by start_benchmark_callback self.__refbox_state_observer.wait_benchmark_state_transition(from_state = RefBoxState.START, to_states = [RefBoxState.EXECUTING_BENCHMARK]) ### normal post conditions: self.__fsm.update(BmBoxState.READY) self.__current_manual_operation = None return def request_manual_operation(self, manual_operation_object=None): """ Requests a manual operation to the refbox. A manual operation consists of a request to the refbox operator to do something. It is possible to prompt the refbox operator to write a response, that will be returned as a string. This function is blocking, meaning the function will only return after the manual operation is complete. :param ManualOperationObject manual_operation_object: The manual operation object, containing the request and the result of the of the manual operation. The result is set after the manual operation has been completed by the refbox operator. """ rospy.logdebug("RefBoxComm.request_manual_operation()") if not isinstance(manual_operation_object, ManualOperationObject): rospy.logerr("request_manual_operation: not isinstance(manual_operation_object, ManualOperationObject)") return if not self.is_benchmark_running(): rospy.loginfo("request_manual_operation: benchmark not running") return if self.__current_manual_operation != None: rospy.logerr("request_manual_operation: another manual operation request is pending") return if not self.check_preconditions(bmbox_states=[BmBoxState.READY, BmBoxState.END], manual_operation_states=[RefBoxState.READY]): rospy.loginfo("request_manual_operation: can not execute request") return self.__current_manual_operation = manual_operation_object self.__fsm.update(BmBoxState.WAITING_MANUAL_OPERATION, self.__current_manual_operation.get_request()) try: execute_manual_operation = rospy.ServiceProxy("bmbox/execute_manual_operation", ExecuteManualOperation) manual_operation_payload = String(data = self.__current_manual_operation.get_request()) response = execute_manual_operation(manual_operation_payload) if response.result.data: self.__update_refbox_state(response.refbox_state) self.__refbox_state_observer.wait_manual_operation_state_transition(from_state = RefBoxState.READY, to_states = [RefBoxState.EXECUTING_MANUAL_OPERATION]) self.__refbox_state_observer.wait_manual_operation_state_transition(from_state = RefBoxState.EXECUTING_MANUAL_OPERATION, to_states = [RefBoxState.READY]) else: rospy.logerr("request_manual_operation: Manual operation FAILED (refbox refused to execute the manual operation)") except rospy.ServiceException, e: rospy.logerr("Service call failed: %s" % (e)) ### normal post conditions: self.__fsm.update(BmBoxState.READY) self.__current_manual_operation = None return
def message_handler(bot, update): state = database_manager.get_user_state(update.message.chat.id) fsm = FSM(state) print("state before is: " + fsm.machine.state) if update.message.text == 'بازشگت به منو اولیه': start(bot, update) elif update.message.text == 'اضافه کردن کلاس': fsm.machine.add_class(update) print("state after is: " + fsm.machine.state) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif update.message.text == 'اضافه کردن استاد': fsm.machine.add_teacher(update) print("state after is: " + fsm.machine.state) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif update.message.text == 'درخواست کلاس': fsm.machine.get_i(update) # go to state for getting instractor print("state after is: " + fsm.machine.state) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif fsm.machine.state == 'new_class': parts = update.message.text.split(' ') class_description = '' for word in parts[2:]: class_description += word + ' ' database_manager.add_class(parts[0], parts[1], class_description) fsm.machine.add_class_finished(update, parts[0], parts[1], class_description) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif fsm.machine.state == 'new_teacher': parts = update.message.text.split(' ') database_manager.add_teacher(parts[0], parts[1]) fsm.machine.add_teacher_finished( update, parts[0], parts[1], ) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif fsm.machine.state == 'get_class_i': temp_map[update.message.chat.id] = [update.message.text] fsm.machine.get_w(update) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif fsm.machine.state == 'get_class_w': temp_map[update.message.chat.id].append(update.message.text) fsm.machine.get_t(update) database_manager.set_user_state(update.message.chat.id, fsm.machine.state) elif fsm.machine.state == 'get_class_t': temp_map[update.message.chat.id].append(update.message.text) taken_class = database_manager.find_and_insert_class( temp_map[update.message.chat.id]) fsm.machine.class_got( update, taken_class, temp_map[update.message.chat.id][0], temp_map[update.message.chat.id][1], temp_map[update.message.chat.id][2], ) del temp_map[update.message.chat.id] database_manager.set_user_state(update.message.chat.id, fsm.machine.state)
mainFile.write("test = SolverForTests(%d, %d)\n" % (fsm.numberOfStates, fsm.numberOfInputs)) mainFile.write( "test.fill_StateCover()\ntest.fill_newStatesDict()\ntest.create_env()\ntest.create_tran_env()\n\ntest.create_formula()\n#test.new_create_transition_formula()\ntest.industrial_transition_formula()\n\n" ) mainFile.write( 'if (test.solver.check() == z3.sat):\n\tprint("sat")\nelse:\n\tprint ("unsat")\n' ) mainFile.close() if __name__ == '__main__': parser = createParamParser() args = parser.parse_args() mainFileName = args.mainFile fsm = FSM() fsm.readFSMfromFile(args.fsmFile) # fsm.printTransitionTable() (inputs, outputs) = readTestFromFile(args.testFile) states = [] (states, outputs) = fsm.getStatesAndOutputsFromTest(inputs) # print ("inp") # print (inputs) # print ("outp") # print (outputs) # print ("states") # print (states) # for i in range(len(inputs)): # print (str(states[i]) + " " + str(inputs[i]) + "/" + str(outputs[i]))
def analysis_str(str: str): state_machine = FSM() for ch in str: state_machine.send(ch) return state_machine.does_match()
@staticmethod def FooLeft(data): if data == "Left": print "trans Left true" return True return False @staticmethod def FooNone(data): if data == "None": print "trans None true" return True return False fsm = FSM(StateIDs.Standing) fsm.addStates() fsm.addTransition(StateIDs.Standing, StateIDs.StartRunningRight, transReqFns.FooRight) fsm.addTransition(StateIDs.StartRunningRight, StateIDs.RunningRight, transReqFns.FooRight) fsm.addTransition(StateIDs.Standing, StateIDs.StartRunningLeft, transReqFns.FooLeft) fsm.addTransition(StateIDs.StartRunningLeft, StateIDs.RunningLeft, transReqFns.FooLeft) fsm.addTransition(StateIDs.StartRunningLeft, StateIDs.Standing, transReqFns.FooNone) fsm.addTransition(StateIDs.StartRunningRight, StateIDs.Standing, transReqFns.FooNone)
def test_init(self): fsm = FSM("start") self.assertEqual("start", fsm.current_state) self.assertIsNone(fsm.prev_state) self.assertIsNone(fsm.action) self.assertEqual({}, fsm.transitions)
def test_add_transition_3args(self): fsm = FSM("on") fsm.add_transition("change", "on", "radio") self.assertEqual(("radio", "on"), fsm.transitions[("change", "on")])
def test_add_transition_4args(self): fsm = FSM("off") fsm.add_transition("play", "off", "music", "on") self.assertEqual(("music", "on"), fsm.transitions[("play", "off")])
from FSM import FSM from KPC_agent import KPC import pdb if __name__ == "__main__": AGENT = KPC() fsm = FSM(AGENT) fsm.setup_rules() while fsm.run: print(fsm.state) #print(AGENT.passcode_buffer) # pdb.set_trace() signal = fsm.get_next_signal() fsm.run_rules(signal)
# Logging should be a class lather on - TODO import logging as log # filename='app.log', filemode='w', log.basicConfig(level=log.INFO, format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S') ### from Camera import Camera # Initializes FSM from FSM import FSM fsm = FSM() # Code smells - any way to do it better? TODO shouldRun = True while (shouldRun): fsm.next_state()
class Lion: def __init__(self, initial_state): self.FSM = FSM(initial_state) self.FSM.add_transition("Antelope", "Hungry", "Eat", "Fed") self.FSM.add_transition("Antelope", "Fed", "Sleep", "Hungry") self.FSM.add_transition("Hunter", "Hungry", "Run away") self.FSM.add_transition("Hunter", "Fed", "Run away", "Hungry") self.FSM.add_transition("Tree", "Hungry", "Sleep") self.FSM.add_transition("Tree", "Fed", "Look", "Hungry") def meet(self, who): self.FSM.execute(who)