def on_enter_old(self): self.fsm.interbot_fsm = statemachine.StateMachine(self.event_loop, "interbot") statemachine.StateMachine(self.event_loop, "opponentdetector", opponent_type = OPPONENT_ROBOT_MAIN) statemachine.StateMachine(self.event_loop, "opponentdetector", opponent_type = OPPONENT_ROBOT_SECONDARY) statemachine.StateMachine(self.event_loop, "relaytoggler") self.robot.stored_fires = 0 self.robot.fruit_tank_trees = 0 self.robot.visited_trees = []
def on_enter(self): statemachine.StateMachine(self.event_loop, "interbot") statemachine.StateMachine(self.event_loop, "opponentdetector", opponent_type=OPPONENT_ROBOT_MAIN) statemachine.StateMachine(self.event_loop, "opponentdetector", opponent_type=OPPONENT_ROBOT_SECONDARY) statemachine.StateMachine(self.event_loop, "relaytoggler") self.robot.mammoth_sparrow_loaded = True
def parse(self, map_str): map_lines = [] map_tokens = [] map_key = {} key_section = sm.matchTest(r"\s*Key:") key_re = re.compile(r"(?P<key>\w+):\s*(?P<name>\w+)") key_match = lambda i,_: key_re.findall(i) def add_keys(_,t): map_key.update(dict(t.result)) # Tests and actions: map_section = sm.matchTest(r"\s*Map:") lex_re = re.compile(r"(?P<room>\[\w+\])|(?P<passage>[-+]+)") # REM: this pattern doesn't explicitly identify ignored chars, have to check spans lex_match = lambda i,_: lex_re.finditer(i) # REM: finditer result is always truish def store_tokens(i,t): map_lines.append(i) map_tokens.append(list(t.result)) # Build the parser: p = sm.StateMachine("map") p.build("map", (key_section, "key"), (lex_match, None, store_tokens), ) p.build("key", (map_section, "map"), (key_match, None, add_keys), (sm.trueTest, None), # Ignore key lines with no definitions ) for l in map_str.splitlines(): p.input(l) self._configure_rooms(map_lines, map_tokens, map_key)
def test_simple_state_switch(self): class State2(statemachine.State): def __init__(self): super(State2, self).__init__() def on_keep_alive(self): self.log("State2 A") yield State1() self.log("State2 B") class State1(statemachine.State): def __init__(self): super(State1, self).__init__() def on_keep_alive(self): self.log("State1 A") yield State2() self.log("State1 B") logger = FsmLogger() start_state = State1() fsm = statemachine.StateMachine(start_state) fsm.logger = logger fsm.dispatch(DummyPacket()) self.assertEquals(State2, fsm.current_state.__class__) self.assertEqual( trim(""" State1 A """), logger.to_string())
def main(): # TODO unicode support # TODO parameterize reorder engine type parser = argparse.ArgumentParser(description="Store reordering tool") parser.add_argument("-l", "--logfile", required=True, help="the pmemcheck log file to process") parser.add_argument("-c", "--checker", required=True, choices=consistencycheckwrap.checkers, help="choose consistency checker type") parser.add_argument("-p", "--path", required=True, help="path to the consistency checker") parser.add_argument("-n", "--name", help="consistency check function for the 'lib' checker") parser.add_argument("-t", "--output_type", choices=loggingfacility.loggers, default="print", help='choose logger type default="print"') parser.add_argument("-o", "--output", help="set the logger output") parser.add_argument("-e", "--output_level", choices=loggingfacility.log_levels, help="set the output log level") parser.add_argument("args", nargs=argparse.REMAINDER, help="remaining args passed to the checker") args = parser.parse_args() logger = loggingfacility.get_logger(args.output_type, args.output, args.output_level) checker = consistencycheckwrap.get_checker(args.checker, args.path, args.name, args.args) # create the script context context = opscontext.OpsContext(args.logfile, checker, logger) # init and run the state machine a = statemachine.StateMachine(statemachine.InitState(context)) a.run_all(context.extract_operations())
def main(): # TODO unicode support # TODO parameterize reorder engine type parser = argparse.ArgumentParser(description="Store reordering tool") parser.add_argument("-l", "--logfile", required=True, help="the pmemcheck log file to process") parser.add_argument("-c", "--checker", required=True, choices=consistencycheckwrap.checkers, help="choose consistency checker type") parser.add_argument("-p", "--path", required=True, help="path to the consistency checker and arguments", nargs='+') parser.add_argument("-n", "--name", help="consistency check function " + "for the 'lib' checker") parser.add_argument("-t", "--output_type", choices=loggingfacility.loggers, default="print", help='choose logger type, default="print"') parser.add_argument("-o", "--output", help="set the logger output") parser.add_argument("-e", "--output_level", choices=loggingfacility.log_levels, help="set the output log level") engines_keys = list(reorderengines.engines.keys()) parser.add_argument("-r", "--default_engine", help="set default reorder engine, default=full", choices=engines_keys, default=engines_keys[0]) args = parser.parse_args() logger = loggingfacility.get_logger(args.output_type, args.output, args.output_level) checker = consistencycheckwrap.get_checker(args.checker, ' '.join(args.path), args.name) engine = reorderengines.get_engine(args.default_engine) # create the script context context = opscontext.OpsContext(args.logfile, checker, logger, engine) # init and run the state machine a = statemachine.StateMachine(statemachine.InitState(context)) if a.run_all(context.extract_operations()) is False: sys.exit(1)
def eval(self, environ): encoding = "iso-8859-1" if "CONTENT_TYPE" in environ: for key, value in urllib.parse.parse_qsl(environ["CONTENT_TYPE"]): if key == "charset": encoding = value break code = str(environ["wsgi.input"].read(), encoding) fsm = statemachine.StateMachine(self.event_loop, "eval", code=code) text = "" if fsm.error is not None: for l in traceback.format_exception(type(fsm.error), fsm.error, None): text += l else: text = "OK" return text
def GameLoop(): global state_machine gameworld.init() state_machine = statemachine.StateMachine(None) while not stop_game: # ask the user what to do next if we there's no next state if state_machine.current_state is None: print("Enter action: ") user_input = input() if user_input in command_handlers: command_handlers[user_input]() else: print("Invalid command: " + user_input) else: state_machine.update()
def start(self): leds.orange.off() leds.green.on() if self.interbot_enabled: if IS_MAIN_ROBOT: InterbotServer(self) else: self.interbot_channel = InterbotControlChannel( self, "IBT", (MAIN_INTERBOT_IP, MAIN_INTERBOT_PORT)) self.mediaplayer_channel = PacketClientSocketChannel( self, "MPL", (MEDIAPLAYER_IP, MEDIAPLAYER_PORT)) self.web_server = asyncwsgiserver.WsgiServer( "", self.webserver_port, webinterface.WebInterface(self)) if SERIAL_PORT_PATH is not None: try: self.turret_channel = TurretChannel(self, SERIAL_PORT_PATH, SERIAL_PORT_SPEED) except serial.SerialException: logger.log( "Unable to open serial port {}".format(SERIAL_PORT_PATH)) self.turret_channel = None self.pic_log_channel = PicLogChannel(self) self.pic_control_channel = PicControlChannel(self) logger.log("Starting brewery with state machine '{}'".format( self.state_machine_name)) statemachine.StateMachine(self, self.state_machine_name) while not self.stopping: while len(self.timers) != 0: if not self.timers[0].check_timeout(): break while len(self.next_timers) != 0: bisect.insort_left(self.timers, self.next_timers.pop()) if len(self.timers) != 0: loop_timeout = max(self.timers[0].remaining_seconds(), 0.0) else: loop_timeout = None asyncore.loop(loop_timeout, True, None, 1)
def test_multiple_substate(self): class State2(statemachine.State): def __init__(self): super(State2, self).__init__() self.result = 0 def on_keep_alive(self): self.log("State2") yield None class State1(statemachine.State): def __init__(self): super(State1, self).__init__() def on_keep_alive(self): self.log("State1 A") state = yield State2() self.log("State1 B") state = yield State2() self.log("State1 C") logger = FsmLogger() start_state = State1() fsm = statemachine.StateMachine(start_state) fsm.logger = logger fsm.dispatch(DummyPacket()) fsm.dispatch(DummyPacket()) fsm.dispatch(DummyPacket()) self.assertEqual( trim(""" State1 A State2 State1 B State2 State1 C """), logger.to_string())
def start(self): leds.orange.off() leds.green.on() if self.interbot_enabled: if IS_MAIN_ROBOT: InterbotServer(self) else: self.interbot_channel = InterbotControlChannel( self, "IBT", (MAIN_INTERBOT_IP, MAIN_INTERBOT_PORT)) self.web_server = asyncwsgiserver.WsgiServer( "", self.webserver_port, webinterface.WebInterface(self)) if SERIAL_PORT_PATH is not None: try: self.turret_channel = TurretChannel(self, SERIAL_PORT_PATH, SERIAL_PORT_SPEED) except serial.SerialException: logger.log( "Unable to open serial port {}".format(SERIAL_PORT_PATH)) self.turret_channel = None self.pic_log_channel = PicLogChannel(self) self.pic_control_channel = PicControlChannel(self) logger.log("Starting brewery with state machine '{}'".format( self.state_machine_name)) statemachine.StateMachine(self, self.state_machine_name) while not self.stopping: if self.timers and self.timers[0].has_timed_out(): loop_timeout = 0.0 else: loop_timeout = EVENT_LOOP_TICK_RESOLUTION_S asyncore.loop(loop_timeout, True, None, 1) for fsm in self.fsms: fsm.on_timer_tick() if self.timers: self.timers[0].check_timeout()
output = list(output) x_list, y_list = np.where(grid != 0) for x, y in zip(x_list, y_list): # find the position to fill the non-zero number rect_position = (7 * grid_size + 2) * (2 * x + 1) + 7 * y + 5 num = grid[x, y] while True: last_ch = str(num % 10) num //= 10 output[rect_position] = last_ch rect_position -= 1 if num == 0: break output = ''.join(output) print(output) if __name__ == "__main__": m = statemachine.StateMachine() m.add_state("Start", start_game) # add start action m.add_state("Continue", continue_game) # add continue action m.add_state("End", None, end_state=1) # add end action m.set_start("Start") grid_size = 4 start_grid = np.zeros((grid_size, grid_size), dtype=int) m.run(start_grid)
def main(): pmreorder_version = "unknown" ''' Argv[1] should be given in order to use -v or --version flag. Argv[1] is passed from the installed script. We must check whether argv[1] was given since it is always a version of pmreorder. ''' if len(sys.argv) > 1 and sys.argv[1][0] != "-": pmreorder_version = sys.argv[1] # TODO unicode support # TODO parameterize reorder engine type parser = argparse.ArgumentParser(description="Store reordering tool") parser.add_argument("-l", "--logfile", required=True, help="the pmemcheck log file to process") parser.add_argument("-c", "--checker", choices=consistencycheckwrap.checkers, default=consistencycheckwrap.checkers[0], help="choose consistency checker type") parser.add_argument("-p", "--path", required=True, help="path to the consistency checker and arguments", nargs='+') parser.add_argument("-n", "--name", help="consistency check function " + "for the 'lib' checker") parser.add_argument("-o", "--output", help="set the logger output file") parser.add_argument("-e", "--output-level", choices=loggingfacility.log_levels, help="set the output log level") parser.add_argument("-x", "--extended-macros", help="list of pairs MARKER=ENGINE or " + "json config file") parser.add_argument("-v", "--version", help="print version of the pmreorder", action="version", version="%(prog)s (" + pmreorder_version + ")") engines_keys = list(reorderengines.engines.keys()) parser.add_argument("-r", "--default-engine", help="set default reorder engine " + "default=NoReorderNoChecker", choices=engines_keys, default=engines_keys[0]) args = parser.parse_args() logger = loggingfacility.get_logger(args.output, args.output_level) checker = consistencycheckwrap.get_checker(args.checker, ' '.join(args.path), args.name) markers = markerparser.MarkerParser().get_markers(args.extended_macros) # create the script context context = opscontext.OpsContext(args.logfile, checker, logger, args.default_engine, markers) # init and run the state machine a = statemachine.StateMachine(statemachine.InitState(context)) if a.run_all(context.extract_operations()) is False: sys.exit(1)
def main(): pmreorder_version = "unknown" """ Argv[1] should be given in order to use -v or --version flag. It is passed from the installation script. We check whether argv[1] was given. If it's not any of regular parameters - we use it as a version of pmreorder and remove it from the arguments list. """ if len(sys.argv) > 1 and sys.argv[1][0] != "-": pmreorder_version = sys.argv[1] del sys.argv[1] # TODO unicode support # TODO parameterize reorder engine type parser = argparse.ArgumentParser(description="Store reordering tool") parser.add_argument( "-l", "--logfile", required=True, help="the pmemcheck log file to process", ) parser.add_argument( "-c", "--checker", choices=consistencycheckwrap.checkers, default=consistencycheckwrap.checkers[0], help="choose consistency checker type", ) parser.add_argument( "-p", "--path", required=True, help="path to the consistency checker and arguments. " + "Note: If program is given, the program has to take " + "a file name as the last parameter.", nargs="+", ) parser.add_argument( "-n", "--name", help="consistency check function for the 'lib' checker. Note: " + "The function has to take a file name as the only parameter.", ) parser.add_argument("-o", "--output", help="set the logger output file") parser.add_argument( "-e", "--output-level", choices=loggingfacility.log_levels, help="set the output log level", ) parser.add_argument( "-x", "--extended-macros", help="list of pairs MARKER=ENGINE or json config file", ) parser.add_argument( "-v", "--version", help="print version of the pmreorder", action="version", version="%(prog)s " + pmreorder_version, ) engines_keys = list(reorderengines.engines.keys()) parser.add_argument( "-r", "--default-engine", help="set default reorder engine default=NoReorderNoChecker", choices=engines_keys, default=engines_keys[0], ) args = parser.parse_args() logger = loggingfacility.get_logger(args.output, args.output_level) checker = consistencycheckwrap.get_checker(args.checker, " ".join(args.path), args.name, logger) markers = markerparser.MarkerParser().get_markers(args.extended_macros) # create the script context context = opscontext.OpsContext(args.logfile, checker, logger, args.default_engine, markers) logger.debug("Input parameters: {}".format(context.__dict__)) # init and run the state machine a = statemachine.StateMachine(statemachine.InitState(context)) if a.run_all(context.extract_operations()) is False: sys.exit(1)
"s": Command("south", "s", help="Go south"), "e": Command("east", "e", help="Go east"), "w": Command("west", "w", help="Go west"), "u": Command("up", "u", help="Go up"), "d": Command("down", "d", help="Go down"), } def look_action(i, t): s = t.dst if t.dst is not None else t.state return s # return adlib(messages.get(s, s)) look_cmd = Command("look", "l", action=look_action, help="Print a description of your surroundings") sorry_action = "Sorry, you can't do that." world = sm.StateMachine("start") # world = StateMachine("start", tracer=20) # Keep a deeper trace, -1 for unlimited # world = StateMachine("start", tracer=Tracer(printer=lambda s: print(f"T: {s}"))) # Complete tracer with prefix world.add(state="start", test=sm.trueTest, dst="01", action=look_action, tag="Start") m = Map(GRID_MAP) m.connect("01", "00", "w") m.connect("01", "02", "e") m.build(world, GO_COMMANDS, look_action) world.add(None, look_cmd, None, look_cmd.action, tag="Look") world.add(None, "xyzzy", "01", look_action, tag="Magic") Command.add_help(world) world.add(None, lambda i,_: i != "crash", None, sorry_action, tag="Not crash") # You can type "crash" to dump the state machine's trace print("Grid World", flush=True)
# -*- coding: utf-8 -*- """ Created on Wed Aug 05 16:15:24 2015 @author: justin.malinchak """ import statemachine import re class MyState(statemachine.State): patterns = {'atransition': r'pattern'} initial_transitions = ['atransition'] def atransition(self, match, context, next_state): # do something result = ['a', 'b'] # a list return context, next_state, result sm = statemachine.StateMachine(state_classes=[MyState], initial_state='MyState') input_string = open('cov1.csv').read() input_lines = statemachine.string2lines(input_string) print input_lines results = sm.run(input_lines) sm.unlink() # context, next_state may be altered