def test1_trans_topology_a(): ao = ActiveObject() ao.start_at(outer) pp(ao.spy_full()) assert (ao.spy_full() == [ 'START', 'SEARCH_FOR_SUPER_SIGNAL:outer', 'ENTRY_SIGNAL:outer', 'INIT_SIGNAL:outer', '<- Queued:(0) Deferred:(0)' ]) pp(ao.spy_full()) print(ao.trace()) event_w = Event(signal=signals.WaitComplete) ao.clear_trace() ao.post_fifo(event_w) import time time.sleep(0.1) pp(ao.spy_rtc()) print(ao.trace()) # clear the spy and the trace ao.clear_spy() ao.clear_trace() # post a number of events and see what happens event_wait_complete = Event(signal=signals.WaitComplete) event_reset_chart = Event(signal=signals.ResetChart) ao.post_fifo(event_wait_complete) ao.post_fifo(event_reset_chart) ao.post_fifo(event_wait_complete) ao.post_fifo(event_reset_chart) time.sleep(0.3) print(ao.trace()) pp(ao.spy_full())
def test_interior_postings_example(): ao = ActiveObject() ao.start_at(middle) time.sleep(0.4) ao.post_fifo(Event(signal=signals.D)) time.sleep(0.5) # if you don't wait it won't look like it is working pp(ao.spy) assert (ao.spy_full() == [ 'START', 'SEARCH_FOR_SUPER_SIGNAL:middle', 'SEARCH_FOR_SUPER_SIGNAL:outer', 'ENTRY_SIGNAL:outer', 'ENTRY_SIGNAL:middle', 'INIT_SIGNAL:middle', '<- Queued:(0) Deferred:(0)', 'A:middle', 'SEARCH_FOR_SUPER_SIGNAL:inner', 'ENTRY_SIGNAL:inner', 'POST_DEFERRED:B', 'INIT_SIGNAL:inner', '<- Queued:(0) Deferred:(1)', 'A:inner', 'A:middle', 'EXIT_SIGNAL:inner', 'SEARCH_FOR_SUPER_SIGNAL:inner', 'ENTRY_SIGNAL:inner', 'POST_DEFERRED:B', 'INIT_SIGNAL:inner', '<- Queued:(0) Deferred:(2)', 'A:inner', 'A:middle', 'EXIT_SIGNAL:inner', 'SEARCH_FOR_SUPER_SIGNAL:inner', 'ENTRY_SIGNAL:inner', 'POST_DEFERRED:B', 'INIT_SIGNAL:inner', '<- Queued:(0) Deferred:(3)', 'D:inner', 'D:middle', 'D:outer', 'RECALL:B', 'POST_FIFO:B', 'D:outer:HOOK', '<- Queued:(1) Deferred:(2)', 'B:inner', 'B:middle', 'B:outer', 'EXIT_SIGNAL:inner', 'EXIT_SIGNAL:middle', 'EXIT_SIGNAL:outer', 'ENTRY_SIGNAL:outer', 'RECALL:B', 'POST_FIFO:B', 'INIT_SIGNAL:outer', '<- Queued:(1) Deferred:(1)', 'B:outer', 'EXIT_SIGNAL:outer', 'ENTRY_SIGNAL:outer', 'RECALL:B', 'POST_FIFO:B', 'INIT_SIGNAL:outer', '<- Queued:(1) Deferred:(0)', 'B:outer', 'EXIT_SIGNAL:outer', 'ENTRY_SIGNAL:outer', 'INIT_SIGNAL:outer', '<- Queued:(0) Deferred:(0)' ])
def test_scribble_to_learn_nature_of_event_processor(): ao = ActiveObject(name="Testing") ao.start_at(s11_state) time.sleep(0.1) ao.post_fifo(Event(signal=signals.T)) time.sleep(0.5) pp(ao.spy())
def test_that_stop_works_within_an_active_object(): ao = ActiveObject('some_state') ao.start_at(some_state) time.sleep(0.1) assert (ao.thread.is_alive() == True) ao.post_fifo(Event(signal=signals.Destroy_This_Chart)) time.sleep(0.1) assert (ao.thread.is_alive() == False)
def test_live_spys(): tazor = ActiveObject() tazor.live_spy = True tazor.live_trace = True tazor.start_at(arming) time.sleep(0.1) tazor.post_fifo(Event(signal=signals.READY)) time.sleep(0.1)
def test_trace_testing(): tazor = ActiveObject() tazor.start_at(arming) time.sleep(0.4) target_with_timestamp = tazor.trace() print(target_with_timestamp) other_with_timestamp = tazor.trace() with stripped(target_with_timestamp) as twt, \ stripped(other_with_timestamp) as owt: for target_item, other_item in zip(twt, owt): print(target_item) assert (target_item == other_item) with stripped( '[2017-11-05 15:17:39.424492] [75c8c] e->BATTERY_CHARGE() armed->armed' ) as swt: assert (swt == '[75c8c] e->BATTERY_CHARGE() armed->armed') assert (tazor.state.fun.__name__ == 'armed')
def augmenting_state_methods_after_creation_and_test(request): def trans_to_s1(chart, e): return chart.trans(s1) def trans_to_c2_s3(chart, e): return chart.trans(s3) def trans_to_c2_s2(chart, e): return chart.trans(s2) def handled(chart, e): return return_status.HANDLED ao = ActiveObject() ao.register_signal_callback(s1, signals.BB, trans_to_s1) ao.register_signal_callback(s1, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(s1, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(s1, signals.INIT_SIGNAL, trans_to_c2_s2) ao.register_parent(s1, ao.top) ao.register_signal_callback(s2, signals.A, trans_to_c2_s3) ao.register_signal_callback(s2, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(s2, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(s2, signals.INIT_SIGNAL, handled) ao.register_parent(s2, s1) ao.register_signal_callback(s3, signals.A, trans_to_c2_s2) ao.register_signal_callback(s3, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(s3, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(s3, signals.INIT_SIGNAL, handled) ao.register_parent(s3, s1) ao.start_at(s2) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.BB)) time.sleep(0.10) yield (ao)
def test_tazor_example(): tazor = ActiveObject() tazor.start_at(arming) time.sleep(0.4) tazor.post_fifo(Event(signal=signals.TRIGGER_PULLED)) time.sleep(0.1) # if you don't wait it won't look like it is working assert (tazor.spy_full() == [ 'START', 'SEARCH_FOR_SUPER_SIGNAL:arming', 'SEARCH_FOR_SUPER_SIGNAL:tazor_operating', 'ENTRY_SIGNAL:tazor_operating', 'ENTRY_SIGNAL:arming', 'INIT_SIGNAL:arming', '<- Queued:(0) Deferred:(0)', 'BATTERY_CHARGE:arming', 'SEARCH_FOR_SUPER_SIGNAL:armed', 'ENTRY_SIGNAL:armed', 'POST_DEFERRED:CAPACITOR_CHARGE', 'INIT_SIGNAL:armed', '<- Queued:(0) Deferred:(1)', 'BATTERY_CHARGE:armed', 'BATTERY_CHARGE:arming', 'EXIT_SIGNAL:armed', 'SEARCH_FOR_SUPER_SIGNAL:armed', 'ENTRY_SIGNAL:armed', 'POST_DEFERRED:CAPACITOR_CHARGE', 'INIT_SIGNAL:armed', '<- Queued:(0) Deferred:(2)', 'BATTERY_CHARGE:armed', 'BATTERY_CHARGE:arming', 'EXIT_SIGNAL:armed', 'SEARCH_FOR_SUPER_SIGNAL:armed', 'ENTRY_SIGNAL:armed', 'POST_DEFERRED:CAPACITOR_CHARGE', 'INIT_SIGNAL:armed', '<- Queued:(0) Deferred:(3)', 'TRIGGER_PULLED:armed', 'TRIGGER_PULLED:arming', 'TRIGGER_PULLED:tazor_operating', 'RECALL:CAPACITOR_CHARGE', 'POST_FIFO:CAPACITOR_CHARGE', 'TRIGGER_PULLED:tazor_operating:HOOK', '<- Queued:(1) Deferred:(2)', 'CAPACITOR_CHARGE:armed', 'CAPACITOR_CHARGE:arming', 'CAPACITOR_CHARGE:tazor_operating', 'EXIT_SIGNAL:armed', 'EXIT_SIGNAL:arming', 'EXIT_SIGNAL:tazor_operating', 'ENTRY_SIGNAL:tazor_operating', 'RECALL:CAPACITOR_CHARGE', 'POST_FIFO:CAPACITOR_CHARGE', 'INIT_SIGNAL:tazor_operating', '<- Queued:(1) Deferred:(1)', 'CAPACITOR_CHARGE:tazor_operating', 'EXIT_SIGNAL:tazor_operating', 'ENTRY_SIGNAL:tazor_operating', 'RECALL:CAPACITOR_CHARGE', 'POST_FIFO:CAPACITOR_CHARGE', 'INIT_SIGNAL:tazor_operating', '<- Queued:(1) Deferred:(0)', 'CAPACITOR_CHARGE:tazor_operating', 'EXIT_SIGNAL:tazor_operating', 'ENTRY_SIGNAL:tazor_operating', 'INIT_SIGNAL:tazor_operating', '<- Queued:(0) Deferred:(0)' ]) print(tazor.trace())
def test_to_code(): ts1 = state_method_template('ts1') tc2_s2 = state_method_template('tc2_s2') tc2_s3 = state_method_template('tc2_s3') def trans_to_s1(chart, e): return chart.trans(ts1) def trans_to_c2_s3(chart, e): return chart.trans(tc2_s3) def trans_to_c2_s2(chart, e): return chart.trans(tc2_s2) def handled(chart, e): return return_status.HANDLED ao = ActiveObject() ao.register_signal_callback(ts1, signals.BB, trans_to_s1) ao.register_signal_callback(ts1, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(ts1, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(ts1, signals.INIT_SIGNAL, trans_to_c2_s2) ao.register_parent(ts1, ao.top) # commented out line needed for test to work ao.register_signal_callback(tc2_s2, signals.A, trans_to_c2_s3) ao.register_signal_callback(tc2_s2, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(tc2_s2, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(tc2_s2, signals.INIT_SIGNAL, handled) ao.register_parent(tc2_s2, ts1) # commented out lines needed for test to work ao.register_signal_callback(tc2_s3, signals.A, trans_to_c2_s2) ao.register_signal_callback(tc2_s3, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(tc2_s3, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(tc2_s3, signals.INIT_SIGNAL, handled) ao.register_parent(tc2_s3, ts1) expected_ts1_as_flat_code = \ ''' @spy_on def ts1(chart, e): status = return_status.UNHANDLED if(e.signal == signals.ENTRY_SIGNAL): status = return_status.HANDLED elif(e.signal == signals.INIT_SIGNAL): status = trans_to_c2_s2(chart, e) elif(e.signal == signals.BB): status = trans_to_s1(chart, e) elif(e.signal == signals.EXIT_SIGNAL): status = return_status.HANDLED else: status, chart.temp.fun = return_status.SUPER, chart.top return status ''' assert (ao.to_code(ts1) == expected_ts1_as_flat_code) expected_tc2_s2_as_flat_code = \ ''' @spy_on def tc2_s2(chart, e): status = return_status.UNHANDLED if(e.signal == signals.ENTRY_SIGNAL): status = return_status.HANDLED elif(e.signal == signals.INIT_SIGNAL): status = return_status.HANDLED elif(e.signal == signals.A): status = trans_to_c2_s3(chart, e) elif(e.signal == signals.EXIT_SIGNAL): status = return_status.HANDLED else: status, chart.temp.fun = return_status.SUPER, ts1 return status ''' assert (ao.to_code(tc2_s2) == expected_tc2_s2_as_flat_code) expected_tc2_s3_as_flat_code = \ ''' @spy_on def tc2_s3(chart, e): status = return_status.UNHANDLED if(e.signal == signals.ENTRY_SIGNAL): status = return_status.HANDLED elif(e.signal == signals.INIT_SIGNAL): status = return_status.HANDLED elif(e.signal == signals.A): status = trans_to_c2_s2(chart, e) elif(e.signal == signals.EXIT_SIGNAL): status = return_status.HANDLED else: status, chart.temp.fun = return_status.SUPER, ts1 return status ''' assert (ao.to_code(tc2_s3) == expected_tc2_s3_as_flat_code) ao.start_at(tc2_s2) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.BB)) time.sleep(0.1) assert(ao.spy() == \ ['START', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:ts1', 'ENTRY_SIGNAL:ts1', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(0) Deferred:(0)', 'A:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s3', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'EXIT_SIGNAL:tc2_s2', 'ENTRY_SIGNAL:tc2_s3', 'INIT_SIGNAL:tc2_s3', '<- Queued:(2) Deferred:(0)', 'A:tc2_s3', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s3', 'EXIT_SIGNAL:tc2_s3', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(1) Deferred:(0)', 'BB:tc2_s2', 'BB:ts1', 'EXIT_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'EXIT_SIGNAL:ts1', 'ENTRY_SIGNAL:ts1', 'INIT_SIGNAL:ts1', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(0) Deferred:(0)'])
@spy_on def c2(chart, e): status = return_status.UNHANDLED if (e.signal == signals.ENTRY_SIGNAL): print("c2 entered") status = return_status.HANDLED elif (e.signal == signals.A): status = chart.trans(c1) else: chart.temp.fun = c status = return_status.SUPER return status if __name__ == "__main__": ao = ActiveObject('start_example') print("calling: start_at(c2)") ao.start_at(c2) time.sleep(0.2) print(ao.trace()) # print what happened from the start_at call ao.clear_trace() # clear our instrumentation print("sending B, then A, then A:") ao.post_fifo(Event(signal=signals.B)) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.A)) time.sleep(0.2) print(ao.trace()) # print what happened
# simple_state_1.py import time from miros import Event from miros import signals from miros import ActiveObject from miros import return_status def outer_state(chart, e): chart.temp.fun = chart.top status = return_status.SUPER return status def inner_state(chart, e): chart.temp.fun = outer_state status = return_status.SUPER return status if __name__ == '__main__': ao = ActiveObject('bob') ao.start_at(outer_state) time.sleep(1)
chart.scribble("run code, but don't transition out of outer_state") status = return_status.HANDLED elif (e.signal == signals.Retry): chart.condition = False if chart.condition else True status = chart.trans(outer_state) else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on def inner_state(chart, e): status = return_status.UNHANDLED if (e.signal == signals.ENTRY_SIGNAL): status = return_status.HANDLED else: chart.temp.fun = outer_state status = return_status.SUPER return status if __name__ == "__main__": ao = ActiveObject('final_icon') ao.augment(name='condition', other=None) ao.live_spy = True ao.start_at(outer_state) ao.post_fifo(Event(signal=signals.Retry)) ao.post_fifo(Event(signal=signals.Retry)) time.sleep(0.01)
@spy_on def inner_state(chart, e): status = return_status.UNHANDLED if (e.signal == signals.ENTRY_SIGNAL): print("{}: hello from inner_state".format(chart.name)) status = return_status.HANDLED elif (e.signal == signals.EXIT_SIGNAL): print("{}: exiting inner_state".format(chart.name)) status = return_status.HANDLED else: chart.temp.fun = outer_state status = return_status.SUPER return status if __name__ == '__main__': ao1 = ActiveObject("ao1") ao1.live_trace = True ao1.start_at(outer_state) ao1.post_fifo(Event(signal=signals.Hook)) ao1.post_fifo(Event(signal=signals.Reset)) ao2 = ActiveObject("ao2") ao2.live_trace = True ao2.start_at(inner_state) ao2.post_fifo(Event(signal=signals.Hook)) ao2.post_fifo(Event(signal=signals.Reset)) # let the thread catch up before we exit main time.sleep(0.01)
import time from miros import spy_on from miros import ActiveObject from miros import signals, Event, return_status @spy_on def some_state(chart, e): status = return_status.UNHANDLED if(e.signal == signals.Destroy_This_Chart): chart.stop() chart.scribble("Terminating Thread") status = return_status.HANDLED else: chart.temp.fun = chart.top status = return_status.SUPER return status if __name__ == "__main__": ao = ActiveObject('some_state') ao.live_spy = True ao.start_at(some_state) time.sleep(0.1) assert(ao.thread.is_alive() == True) ao.post_fifo(Event(signal=signals.Destroy_This_Chart)) time.sleep(0.1) assert(ao.thread.is_alive() == False)
@spy_on def source_state(chart, e): status = return_status.UNHANDLED if (e.signal == signals.SIGNAL_NAME): if guard(): action() chart.post_fifo(Event(signal=signals.EVT_A)) status = chart.trans(target_state) else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on def target_state(chart, e): chart.temp.fun = chart.top status = return_status.SUPER return status if __name__ == "__main__": # event arrow example ao = ActiveObject('eae') ao.live_trace = True ao.start_at(source_state) ao.post_fifo( Event(signal=signals.SIGNAL_NAME, payload=OptionalPayload(x='1'))) time.sleep(0.01)
def test_graffiti_spy(): ao = ActiveObject(name="scribbled_on") ao.start_at(g1_s22_active_objects_graph) time.sleep(0.2) pp(ao.spy())
def test_creating_functions_from_a_template(): ts1 = state_method_template('ts1') tc2_s2 = state_method_template('tc2_s2') tc2_s3 = state_method_template('tc2_s3') def trans_to_s1(chart, e): return chart.trans(ts1) def trans_to_c2_s3(chart, e): return chart.trans(tc2_s3) def trans_to_c2_s2(chart, e): return chart.trans(tc2_s2) def handled(chart, e): return return_status.HANDLED ao = ActiveObject() ao.register_signal_callback(ts1, signals.BB, trans_to_s1) ao.register_signal_callback(ts1, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(ts1, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(ts1, signals.INIT_SIGNAL, trans_to_c2_s2) ao.register_parent(ts1, ao.top) ao.register_signal_callback(tc2_s2, signals.A, trans_to_c2_s3) ao.register_signal_callback(tc2_s2, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(tc2_s2, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(tc2_s2, signals.INIT_SIGNAL, handled) ao.register_parent(tc2_s2, ts1) ao.register_signal_callback(tc2_s3, signals.A, trans_to_c2_s2) ao.register_signal_callback(tc2_s3, signals.ENTRY_SIGNAL, handled) ao.register_signal_callback(tc2_s3, signals.EXIT_SIGNAL, handled) ao.register_signal_callback(tc2_s3, signals.INIT_SIGNAL, handled) ao.register_parent(tc2_s3, ts1) ao.start_at(tc2_s2) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.A)) ao.post_fifo(Event(signal=signals.BB)) time.sleep(0.1) assert(ao.spy() == \ ['START', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:ts1', 'ENTRY_SIGNAL:ts1', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(0) Deferred:(0)', 'A:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s3', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'EXIT_SIGNAL:tc2_s2', 'ENTRY_SIGNAL:tc2_s3', 'INIT_SIGNAL:tc2_s3', '<- Queued:(2) Deferred:(0)', 'A:tc2_s3', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s3', 'EXIT_SIGNAL:tc2_s3', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(1) Deferred:(0)', 'BB:tc2_s2', 'BB:ts1', 'EXIT_SIGNAL:tc2_s2', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'EXIT_SIGNAL:ts1', 'ENTRY_SIGNAL:ts1', 'INIT_SIGNAL:ts1', 'SEARCH_FOR_SUPER_SIGNAL:tc2_s2', 'ENTRY_SIGNAL:tc2_s2', 'INIT_SIGNAL:tc2_s2', '<- Queued:(0) Deferred:(0)'])
status = return_status.UNHANDLED # the event processor is asking us about events called INIT_SIGNAL if (e.signal == signals.INIT_SIGNAL): # we are transitioning to inner_state # we let the trans method, set temp.fun and our return status status = chart.trans(inner_state) # we do this for any other event else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on # enables the live trace def inner_state(chart, e): # we do this for all events chart.temp.fun = outer_state status = return_status.SUPER return status if __name__ == '__main__': ao = ActiveObject('ao') ao.live_trace = True # so we can see what is happening # Create a thread and start our state machine ao.start_at(outer_state) # Run our main program so that the state machine's thread # can do some stuff. # The state machine's thread will be stopped when our main thread stops time.sleep(0.01)
status = chart.trans(a1) else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on def a1(chart, e): if (e.signal == signals.ENTRY_SIGNAL): print("'a1' entered") status = return_status.HANDLED elif (e.signal == signals.EXIT_SIGNAL): print("'a1' exited") status = return_status.HANDLED else: chart.temp.fun = a status = return_status.SUPER return status if __name__ == "__main__": # simple hook example 2 ao = ActiveObject(name="she2") ao.live_trace = True ao.start_at(a1) ao.post_fifo(Event(signal=signals.SIGNAL_NAME)) ao.post_fifo(Event(signal=signals.Reset)) # starting another thread, let it run for a moment before we shut down time.sleep(0.01)
print("exiting outer_state") status = return_status.HANDLED else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on def inner_state(chart, e): status = return_status.UNHANDLED if (e.signal == signals.ENTRY_SIGNAL): print("hello from inner_state") status = return_status.HANDLED elif (e.signal == signals.EXIT_SIGNAL): print("exiting inner_state") status = return_status.HANDLED else: chart.temp.fun = outer_state status = return_status.SUPER return status if __name__ == '__main__': ao = ActiveObject("ao") ao.live_trace = True ao.start_at(outer_state) ao.post_fifo(Event(signal=signals.Reset)) # let the thread catch up before we exit main time.sleep(0.01)
status = chart.trans(off) elif (e.signal == signals.too_hot): status = chart.trans(idling) else: chart.temp.fun = chart.top status = return_status.SUPER return status @spy_on def idling(chart, e): status = return_status.UNHANDLED if (e.signal == signals.too_cold): status = chart.trans(heating) else: chart.temp.fun = chart.top status = return_status.SUPER return status if __name__ == "__main__": ao = ActiveObject('simple_fsm_2') ao.live_trace = True ao.start_at(off) ao.post_fifo(Event(signal=signals.bake_pressed)) ao.post_fifo(Event(signal=signals.off_pressed)) ao.post_fifo(Event(signal=signals.bake_pressed)) ao.post_fifo(Event(signal=signals.too_hot)) ao.post_fifo(Event(signal=signals.too_cold)) time.sleep(0.01)