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
