def test(self):
tick1 = EntryExitSelfLogic()
t0 = {"source": "initial", "target": "s1"}
t1 = {
"trigger": "b",
"source": "s1",
"target": "s1",
"effect": "add('b')"
}
t2 = {
"trigger": "done",
"source": "s1",
"target": "final",
"effect": "add('c')",
}
s1 = {"name": "s1", "do": "do_action('a')"}
stm = Machine(name="stm",
transitions=[t0, t1, t2],
states=[s1],
obj=tick1)
tick1.stm = stm
_ = stmpy.get_graphviz_dot(stm)
driver = Driver()
driver.add_machine(stm)
driver.start()
driver.wait_until_finished()
def test(self):
terminate = Terminate()
t0 = {"source": "initial", "target": "s_1"}
t1 = {
"trigger": "t",
"source": "s_1",
"target": "s_2",
"effect": "action"
}
stm_terminate = Machine(name="stm_terminate",
transitions=[t0, t1],
obj=terminate)
terminate.stm = stm_terminate
scheduler = Driver()
scheduler.add_machine(stm_terminate)
scheduler.start(max_transitions=2, keep_active=False)
scheduler.send("t", "stm_terminate")
scheduler.wait_until_finished()
_ = stmpy.get_graphviz_dot(stm_terminate)
_ = scheduler.print_status()
self.assertTrue(True)
def test(self):
cfc = CompoundFunctionContainer(13)
t0 = {"source": "initial", "target": "s1"}
t1 = {
"trigger": "a",
"source": "s1",
"function": cfc.compound,
"targets": "s2 s3",
}
t2 = {"trigger": "b", "source": "s2", "target": "final"}
t3 = {"trigger": "b", "source": "s3", "target": "final"}
stm = Machine(name="stm", transitions=[t0, t1, t2, t3], obj=None)
_ = stmpy.get_graphviz_dot(stm)
driver = Driver()
driver.add_machine(stm)
driver.start(keep_active=False)
driver.send("a", "stm", args=["hi"], kwargs={"b1": "bbb"})
driver.send("b", "stm")
driver.wait_until_finished()
def test(self):
t0 = {
"source": "initial",
"target": "s1",
"effect": "start_timer('t1', 1000)",
}
t1 = {
"trigger": "a",
"source": "s1",
"target": "s1",
"effect": "stop_timer('t1')",
}
t2 = {"trigger": "b", "source": "s1", "target": "final"}
stm = Machine(name="stm", transitions=[t0, t1, t2], obj=None)
_ = stmpy.get_graphviz_dot(stm)
driver = Driver()
driver.add_machine(stm)
driver.start(keep_active=False)
driver.send("a", "stm")
driver.send("b", "stm")
driver.wait_until_finished()
def test_blink():
blink = Blink()
t0 = {"source": "initial", "target": "blink_on", "effect": "on"}
t1 = {
"trigger": "t",
"source": "blink_on",
"target": "blink_off",
"effect": "off"
}
t2 = {
"trigger": "t",
"source": "blink_off",
"target": "blink_on",
"effect": "on"
}
stm_blink = Machine(transitions=[t0, t1, t2], obj=blink, name="blink")
blink.stm = stm_blink
print(stm_blink.print_graph())
scheduler = Driver()
scheduler.add_stm(stm_blink)
scheduler.start()
print("scheduler started")
scheduler.wait_until_finished()
def test_tick_2():
logger = logging.getLogger("stmpy.Driver")
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
scheduler = Driver()
tick = Tick_2()
t0 = {"source": "initial", "target": "s_tick", "effect": "on_init"}
t1 = {"trigger": "tick", "source": "s_tick", "function": tick.t_1}
t2 = {"trigger": "tock", "source": "s_tock", "function": tick.t_2}
stm_tick = Machine(name="stm_tick", transitions=[t0, t1, t2], obj=tick)
# the object may need the stm to add events and control timers
tick.stm = stm_tick
scheduler.add_stm(stm_tick)
scheduler.start(max_transitions=10)
scheduler.wait_until_finished()
def test(self):
print(__name__)
debug_level = logging.DEBUG
logger = logging.getLogger(__name__)
logger.setLevel(debug_level)
ch = logging.StreamHandler()
ch.setLevel(debug_level)
formatter = logging.Formatter(
"%(asctime)s - %(name)-12s - %(levelname)-8s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
# terminate = Terminate()
t0 = {"source": "initial", "target": "s1"}
t1 = {"trigger": "b", "source": "s1", "target": "s2"}
t2 = {"trigger": "a", "source": "s2", "target": "final"}
s1 = {"name": "s1", "a": "defer", "a2": "defer", "a3": "defer"}
s2 = {"name": "s2", "a2": "defer", "a3": "defer"}
stm_terminate = Machine(name="stm",
transitions=[t0, t1, t2],
states=[s1, s2],
obj=None)
# terminate.stm = stm_terminate
_ = stmpy.get_graphviz_dot(stm_terminate)
print(_)
def unwrap(queue):
s = []
if queue is None:
return s
for event in queue:
if event is not None:
s.append(event["id"])
return s
driver = Driver()
driver.add_machine(stm_terminate)
driver.start(max_transitions=30, keep_active=False)
driver.send("a", "stm")
driver.send("a2", "stm")
driver.send("a3", "stm")
print("Events {}".format(unwrap(driver._event_queue.queue)))
print(stm_terminate.state)
print("Defers {}".format(unwrap(stm_terminate._defer_queue)))
print(driver._max_transitions)
driver.send("b", "stm")
print("Events {}".format(unwrap(driver._event_queue.queue)))
print(stm_terminate.state)
print("Defers {}".format(unwrap(stm_terminate._defer_queue)))
print(driver._max_transitions)
driver.wait_until_finished()
print(stm_terminate.state)
self.assertTrue(True)
def test(self):
busy = Busy()
t0 = {"source": "initial", "target": "s_busy", "effect": "on_busy"}
t1 = {
"trigger": "busy",
"source": "s_busy",
"target": "s_busy",
"effect": "on_busy",
}
stm_busy = Machine(name="busy", transitions=[t0, t1], obj=busy)
busy.stm = stm_busy
scheduler = Driver()
scheduler.add_machine(stm_busy)
scheduler.start(max_transitions=5)
scheduler.wait_until_finished()
self.assertTrue(True)
def test_busy():
busy = Busy()
t0 = {"source": "initial", "target": "s_busy", "effect": "on_busy"}
t1 = {
"trigger": "busy",
"source": "s_busy",
"target": "s_busy",
"effect": "on_busy",
}
stm_busy = Machine(transitions=[t0, t1], obj=busy, name="stm_busy")
busy.stm = stm_busy
scheduler = Driver()
scheduler.add_stm(stm_busy)
scheduler.start(max_transitions=100)
print("scheduler started")
scheduler.wait_until_finished()
def test(self):
t0 = {"source": "initial", "target": "s1"}
t1 = {
"trigger": "a",
"source": "s1",
"function": self.compound,
"targets": "final",
}
stm = Machine(name="stm", transitions=[t0, t1], obj=None)
_ = stmpy.get_graphviz_dot(stm)
driver = Driver()
driver.add_machine(stm)
driver.start(keep_active=False)
driver.send("a", "stm", args=["hi"], kwargs={"b1": "bbb"})
driver.wait_until_finished()
def test(self):
two = TwoMethods()
t0 = {"source": "initial", "target": "s_1"}
t1 = {
"trigger": "t",
"source": "s_1",
"target": "s_2",
"effect": "m1;m2"
}
stm_two = Machine(name="stm_two", transitions=[t0, t1], obj=two)
two.stm = stm_two
scheduler = Driver()
scheduler.add_machine(stm_two)
scheduler.start(max_transitions=2)
print("scheduler started")
scheduler.send("t", "stm_two")
scheduler.wait_until_finished()
self.assertTrue(True)
def test(self):
tick1 = EntryExitSelfLogic()
t0 = {"source": "initial", "target": "s1"}
t1 = {
"trigger": "b",
"source": "s1",
"target": "s1",
"effect": "add('b')"
}
t2 = {
"trigger": "c",
"source": "s1",
"target": "final",
"effect": "add('c')"
}
s1 = {
"name": "s1",
"a": "add('a')",
"entry": "add('entry')",
"exit": "add('exit')",
}
stm = Machine(name="stm",
transitions=[t0, t1, t2],
states=[s1],
obj=tick1)
tick1.stm = stm
_ = stmpy.get_graphviz_dot(stm)
driver = Driver()
driver.add_machine(stm)
driver.start(max_transitions=30, keep_active=False)
driver.send("a", "stm")
driver.send("b", "stm")
driver.send("c", "stm")
driver.wait_until_finished()
logger.setLevel(debug_level)
ch = logging.StreamHandler()
ch.setLevel(debug_level)
formatter = logging.Formatter(
"%(asctime)s - %(name)-12s - %(levelname)-8s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
print(stmpy.__version__)
speaker = Speaker()
t0 = {"source": "initial", "target": "ready"}
t1 = {"trigger": "speak", "source": "ready", "target": "speaking"}
t2 = {"trigger": "done", "source": "speaking", "target": "ready"}
s1 = {"name": "speaking", "do": "speak(*)", "speak": "defer"}
stm = Machine(name="stm", transitions=[t0, t1, t2], states=[s1], obj=speaker)
speaker.stm = stm
driver = Driver()
driver.add_machine(stm)
driver.start()
driver.send("speak", "stm", args=["My first sentence."])
driver.send("speak", "stm", args=["My second sentence."])
driver.send("speak", "stm", args=["My third sentence."])
driver.send("speak", "stm", args=["My fourth sentence."])
driver.wait_until_finished()
def test(self):
# print(stmpy.__version__)
logger = logging.getLogger("stmpy")
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
tick1 = Tick()
t0 = {
"source": "initial",
"target": "active",
"effect": "start_timer('tick', 1000); print('initial1')",
}
#'effect': 'print("initial1")'}
t1 = {
"trigger": "tick",
"source": "active",
"target": "active",
"effect": "start_timer('tick', 1000); print('timeout1')",
}
#'effect': 'print("timeout1")'}
stm_tick_1 = Machine(name="stm_tick_1",
transitions=[t0, t1],
obj=tick1)
tick1.stm = stm_tick_1
tick2 = Tick()
t0 = {
"source": "initial",
"target": "active",
"effect": "start_timer('tick', 2000); print('initial2')",
}
#'effect': 'print("initial2")'}
t1 = {
"trigger": "tick",
"source": "active",
"target": "active",
"effect": "start_timer('tick', 1000); print('timeout2')",
}
stm_tick_2 = Machine(name="stm_tick_2",
transitions=[t0, t1],
obj=tick2)
tick2.stm = stm_tick_2
driver1 = Driver()
driver1.start(max_transitions=6, keep_active=True)
print("driver state: active {} and thread alive {} ".format(
driver1._active, driver1.thread.is_alive()))
driver1.add_machine(stm_tick_1)
print(driver1.print_status())
driver1.add_machine(stm_tick_2)
print(driver1.print_status())
driver1._wake_queue()
print("driver state: active {} and thread alive {} ".format(
driver1._active, driver1.thread.is_alive()))
# driver1.start(max_transitions=6, keep_active=True)
print(driver1.print_status())
# driver2 = Driver()
# driver1.add_machine(stm_tick_2)
# driver2.start(max_transitions=10)
driver1.wait_until_finished()