def test_reset_to_history_id(gui): state_machine_m, state_dict = create_state_machine_m(gui) sm_history = state_machine_m.history state1_id = state_dict["State1"].state_id state2_id = state_dict["State2"].state_id # Remove two child states of root state gui(state_machine_m.root_state.state.remove_state, state1_id) # history id 1 gui(state_machine_m.root_state.state.remove_state, state2_id) # history id 2 history_2_hash = state_machine_m.mutable_hash().hexdigest() # Undo removal gui(state_machine_m.history.undo) gui(state_machine_m.history.undo) # Create new history branch by adding two new states state4 = ExecutionState("State4") state5 = ExecutionState("State5") gui(state_machine_m.root_state.state.add_state, state4) # history id 3 gui(state_machine_m.root_state.state.add_state, state5) # history id 4 assert state_machine_m.history.modifications.current_history_element.history_id == 4 history_4_hash = state_machine_m.mutable_hash().hexdigest() # Activate old branch gui(state_machine_m.history.reset_to_history_id, 2) reset_history_2_hash = state_machine_m.mutable_hash().hexdigest() assert history_2_hash == reset_history_2_hash # Activate new branch gui(state_machine_m.history.reset_to_history_id, 4) reset_history_4_hash = state_machine_m.mutable_hash().hexdigest() assert history_4_hash == reset_history_4_hash
def test_simple_undo_redo(caplog): testing_utils.dummy_gui(None) testing_utils.initialize_environment(gui_config={ 'AUTO_BACKUP_ENABLED': False, 'HISTORY_ENABLED': True }, gui_already_started=False) state_machine_m, state_dict = create_state_machine_m() state1 = ExecutionState('state1', state_id='STATE1') state2 = ExecutionState('state2', state_id='STATE2') state3 = ExecutionState('state2', state_id='STATE2') state4 = ExecutionState('state2', state_id='STATE2') state_machine_m.root_state.state.add_state(state1) state_machine_m.root_state.state.add_state(state2) state_machine_m.root_state.state.add_state(state3) state_machine_m.root_state.state.add_state(state4) assert len(state_machine_m.history.modifications) == 5 perform_multiple_undo(2) perform_multiple_redo(1) perform_multiple_redo(1) assert len(state_machine_m.history.modifications) == 5 testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False, expected_errors=0)
def __init__(self, name=None, state_id=None, input_data_ports=None, output_data_ports=None, income=None, outcomes=None, path=None, filename=None, safe_init=True): if state_id is None: state_id = UNIQUE_DECIDER_STATE_ID ExecutionState.__init__(self, name, state_id, input_data_ports, output_data_ports, income, outcomes, path, filename, safe_init=safe_init) self.child_errors = {} self.final_outcomes_dict = {}
def test_multiple_future_element(): testing_utils.dummy_gui(None) from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.gui.models.state import StateModel from rafcon.gui.models.container_state import ContainerStateModel parent_state = HierarchyState() parent_state_m = ContainerStateModel(parent_state) child_state_a = ExecutionState("A") child_state_a_m = StateModel(child_state_a) child_state_b = ExecutionState("B") child_state_b_m = StateModel(child_state_b) parent_state_m.expected_future_models.add(child_state_a_m) parent_state_m.expected_future_models.add(child_state_b_m) parent_state.add_state(child_state_a) assert len(parent_state_m.states) == 1 new_child_state_a_m = list(parent_state_m.states.values())[0] assert new_child_state_a_m is child_state_a_m assert new_child_state_a_m.core_element is child_state_a assert len(parent_state_m.expected_future_models) == 1 parent_state.add_state(child_state_b) assert len(parent_state_m.states) == 2 new_child_states_m = list(parent_state_m.states.values()) assert new_child_states_m[0] is child_state_b_m or new_child_states_m[ 1] is child_state_b_m assert new_child_states_m[ 0].core_element is child_state_b or new_child_states_m[ 1].core_element is child_state_b assert len(parent_state_m.expected_future_models) == 0
def create_preemption_state_machine(): state1 = ExecutionState("FirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrence_preemption1.py") state1.add_outcome("FirstOutcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "float") state2 = ExecutionState("SecondState", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrence_preemption2.py") state2.add_outcome("FirstOutcome", 3) input_state2 = state2.add_input_data_port("input_data_port1", "float") state3 = PreemptiveConcurrencyState("FirstConcurrencyState") state3.add_state(state1) state3.add_state(state2) state3.add_outcome("State1 preempted", 3) input_state3 = state3.add_input_data_port("input_data_port1", "float", 0.1) input2_state3 = state3.add_input_data_port("input_data_port2", "float", 0.1) state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state3.state_id, input2_state3, state2.state_id, input_state2) state3.add_transition(state1.state_id, 3, state3.state_id, 3) return StateMachine(state3)
def test_connections_from_object_type(caplog): parent_state = HierarchyState("parent") child_state = ExecutionState("child") parent_state.add_state(child_state) parent_obj_port_id = parent_state.add_input_data_port("obj", data_type=object, default_value=None) parent_int_port_id = parent_state.add_input_data_port("int", data_type=int, default_value=None) child_obj_port_id = child_state.add_input_data_port("obj", data_type=object, default_value=0) child_int_port_id = child_state.add_input_data_port("int", data_type=int, default_value=0) # Connection from specific type int to generic type object parent_state.add_data_flow(parent_state.state_id, parent_int_port_id, child_state.state_id, child_obj_port_id) # Connection from generic type object to specific type int parent_state.add_data_flow(parent_state.state_id, parent_obj_port_id, child_state.state_id, child_int_port_id) testing_utils.assert_logger_warnings_and_errors(caplog, expected_warnings=0, expected_errors=0)
def test_state_type_change_bugs_with_gui(gui): sm_manager_model = gui.singletons.state_machine_manager_model sm_m, state_dict = create_state_machine_m(gui) check_elements_ignores.append("internal_transitions") # General Type Change inside of a state machine (NO ROOT STATE) ############ state_of_type_change = 'State3' parent_of_type_change = 'Container' # do state_type_change with gui gui(sm_m.history.modifications.reset) state_m = sm_m.get_state_model_by_path( state_dict[state_of_type_change].get_path()) gui(sm_m.selection.set, [state_m]) current_sm_length = len(sm_manager_model.state_machines) # print "1:", sm_manager_model.state_machines.keys() logger.debug('number of sm is : {0}'.format( sm_manager_model.state_machines.keys())) def create_simple_state_machine(): root_state = HierarchyState("new root state", state_id="ROOT") state_machine = StateMachine(root_state) sm_manager_model.state_machine_manager.add_state_machine(state_machine) return state_machine state_machine = gui(create_simple_state_machine) logger.debug('number of sm is : {0}'.format( sm_manager_model.state_machines.keys())) assert len(sm_manager_model.state_machines) == current_sm_length + 1 sm_m = sm_manager_model.state_machines[state_machine.state_machine_id] h_state1 = HierarchyState(state_id='HSTATE1') gui(sm_m.state_machine.root_state.add_state, h_state1) h_state2 = HierarchyState(state_id='HSTATE2') gui(h_state1.add_state, h_state2) ex_state1 = ExecutionState(state_id='EXSTATE1') gui(h_state1.add_state, ex_state1) ex_state2 = ExecutionState(state_id='EXSTATE2') gui(h_state2.add_state, ex_state2) logger.info("DO_TYPE_CHANGE") h_state1_m = sm_m.get_state_model_by_path(h_state1.get_path()) do_type_change(sm_m, h_state1_m, ExecutionState, gui) logger.info("UNDO") gui(sm_m.history.undo) logger.info("UNDO finished") logger.info("REDO") gui(sm_m.history.redo) logger.info("REDO finished") check_elements_ignores.remove("internal_transitions") print(check_elements_ignores)
def create_state_machine(): from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1', state_id='STATE1') state2 = ExecutionState('State2') state4 = ExecutionState('Nested') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id='STATE3') state3.add_state(state4) state3.add_state(state5) state3.set_start_state(state4) state3.add_scoped_variable("share", "int", 3) state3.add_transition(state4.state_id, 0, state5.state_id, None) state3.add_transition(state5.state_id, 0, state3.state_id, 0) state3.add_data_flow(state4.state_id, output_state4, state5.state_id, input_state5) ctr_state = HierarchyState(name="Container", state_id='ROOTSTATE') ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) ctr_state.set_start_state(state1) ctr_state.add_transition(state1.state_id, 0, state2.state_id, None) ctr_state.add_transition(state2.state_id, 0, state3.state_id, None) ctr_state.add_transition(state3.state_id, 0, ctr_state.state_id, 0) ctr_state.name = "Container" state_machine = StateMachine(ctr_state) return state_machine
def create_hierarchy_state(number_child_states=10, sleep=False): hierarchy = HierarchyState("hierarchy1") hierarchy.add_outcome("hierarchy_outcome", 1) hierarchy.add_input_data_port("hierarchy_input_port1", "float", 42.0) hierarchy.add_output_data_port("hierarchy_output_port1", "float") last_state = None for i in range(number_child_states): if sleep: state = ExecutionState("state" + str(i), path=testing_utils.TEST_SCRIPT_PATH, filename="hello_world_sleep.py") else: state = ExecutionState("state" + str(i)) hierarchy.add_state(state) state.add_input_data_port("input1", "float") state.add_output_data_port("output1", "float") if not last_state: hierarchy.set_start_state(state.state_id) hierarchy.add_data_flow( hierarchy.state_id, hierarchy.get_io_data_port_id_from_name_and_type( "hierarchy_input_port1", InputDataPort), state.state_id, state.get_io_data_port_id_from_name_and_type( "input1", InputDataPort)) else: hierarchy.add_transition(last_state.state_id, 0, state.state_id, None) # connect data ports state 1 hierarchy.add_data_flow( last_state.state_id, last_state.get_io_data_port_id_from_name_and_type( "output1", OutputDataPort), state.state_id, state.get_io_data_port_id_from_name_and_type( "input1", InputDataPort)) last_state = state hierarchy.add_data_flow( last_state.state_id, last_state.get_io_data_port_id_from_name_and_type( "output1", OutputDataPort), hierarchy.state_id, hierarchy.get_io_data_port_id_from_name_and_type( "hierarchy_output_port1", OutputDataPort)) hierarchy.add_transition(last_state.state_id, 0, hierarchy.state_id, 1) return hierarchy
def test_container_state(caplog): container = ContainerState("Container") input_container_state = container.add_input_data_port("input", "float") output_container_state = container.add_output_data_port("output", "float") scoped_variable_container_state = container.add_scoped_variable( "scope", "float") state1 = ExecutionState("test_execution_state") input_state1 = state1.add_input_data_port("input", "float") output_state1 = state1.add_output_data_port("output", "float") container.add_state(state1) transition_id = container.add_transition(state1.state_id, 0, container.state_id, -2) container.add_data_flow(container.state_id, input_container_state, state1.state_id, input_state1) container.add_data_flow(state1.state_id, output_state1, container.state_id, output_container_state) container.add_data_flow(container.state_id, input_container_state, container.state_id, scoped_variable_container_state) transition = container.get_transition_for_outcome(state1, state1.outcomes[0]) # Test transition from outcome assert (transition == container.transitions[transition_id]) # Test contains assert (transition in container) # Test dictionary dict_state = ContainerState.state_to_dict(container) # print(dict_state) container2, transitions, data_flows = ContainerState.from_dict(dict_state) print(container) print(container2) assert (container == copy.copy(container)) assert (container == copy.deepcopy(container)) new_state1 = ExecutionState("new_test_execution_state") old_state1_id = state1.state_id new_state = container.substitute_state(state1.state_id, new_state1) assert (old_state1_id == state1.state_id) assert (not new_state.state_id == old_state1_id) assert_logger_warnings_and_errors(caplog)
def create_models(*args, **kargs): import rafcon.core.singleton from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.state_machine import StateMachine state1 = HierarchyState('State1', state_id="State1") state2 = ExecutionState('State2', state_id="State2") ctr_state = HierarchyState(name="Root", state_id="Root") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.start_state_id = state1.state_id ctr_state.add_transition(state1.state_id, from_outcome=0, to_state_id=state2.state_id, to_outcome=None) ctr_state.add_transition(state2.state_id, from_outcome=0, to_state_id=ctr_state.state_id, to_outcome=0) ctr_state.name = "Container" sm = StateMachine(ctr_state) # add new state machine rafcon.core.singleton.state_machine_manager.add_state_machine(sm) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm.state_machine_id
def execute(self, inputs, outputs, gvm): self.logger.debug("Insert state") e = ExecutionState() self.parent.add_state(e) self.parent.add_transition(self.state_id, 0, e.state_id, None) self.parent.add_transition(e.state_id, 0, self.parent.state_id, 0) return 0
def test_port_and_outcome_removal(caplog): container = ContainerState("Container") input_container_state = container.add_input_data_port("input", "float") output_container_state = container.add_output_data_port("output", "float") scoped_variable_container_state = container.add_scoped_variable( "scope", "float") assert len(container.transitions) == 0 assert len(container.data_flows) == 0 assert len(container.outcomes) == 3 assert len(container.input_data_ports) == 1 assert len(container.output_data_ports) == 1 assert len(container.scoped_variables) == 1 state1 = ExecutionState("test_execution_state") input_state1 = state1.add_input_data_port("input", "float") output_state1 = state1.add_output_data_port("output", "float") container.add_state(state1) container.add_transition(state1.state_id, 0, container.state_id, -2) container.add_data_flow(container.state_id, input_container_state, state1.state_id, input_state1) container.add_data_flow(state1.state_id, output_state1, container.state_id, output_container_state) container.add_data_flow(container.state_id, input_container_state, container.state_id, scoped_variable_container_state) assert len(container.transitions) == 1 assert len(container.data_flows) == 3 state1.remove_outcome(0) assert len(container.transitions) == 0 state1.remove_output_data_port(output_state1) assert len(container.data_flows) == 2 state1.remove_input_data_port(input_state1) assert len(container.data_flows) == 1 container.remove_scoped_variable(scoped_variable_container_state) assert len(container.data_flows) == 0 assert_logger_warnings_and_errors(caplog)
def test_group_states(caplog): container = ContainerState("Container") input_port_container_state = container.add_input_data_port( "input", "float") container.add_output_data_port("output", "float") container.add_scoped_variable("scope_1", "float") container.add_scoped_variable("scope_2", "float") state1 = ExecutionState("MyFirstState") container.add_state(state1) new_state_id = container.add_state( ExecutionState("test_execution_state", state_id=state1.state_id)) container.remove_state(new_state_id) state2 = ExecutionState("2nd State", state_id=container.state_id) logger.debug("Old state id: {0}".format(str(state2.state_id))) new_state_id = container.add_state(state2) logger.debug("New state id: {0}".format(str(new_state_id))) input_state1 = state1.add_input_data_port("input", "float") output_state1 = state1.add_output_data_port("output", "float") input_state2 = state2.add_input_data_port("input", "float") input2_state2 = state2.add_input_data_port("input2", "float") output_state2 = state2.add_output_data_port("output", "float") container.add_data_flow(state1.state_id, output_state1, state2.state_id, input_state2) container.add_data_flow(container.state_id, input_port_container_state, state1.state_id, input_state1) container.add_data_flow(state2.state_id, output_state2, state2.state_id, input2_state2) container.add_transition(state1.state_id, -1, state2.state_id, None) container.add_transition(state1.state_id, -2, container.state_id, -2) container.add_transition(state2.state_id, -1, container.state_id, -1) group_state = container.group_states([state1.state_id, state2.state_id]) container.ungroup_state(group_state.state_id) assert_logger_warnings_and_errors(caplog)
def test_lock_state_machine(caplog): state_machine = StateMachine() @lock_state_machine def custom_function(object, number): raise AttributeError("Test error") State.custom_method = custom_function state1 = ExecutionState("s1") state_machine.root_state = state1 try: state1.custom_method(5) except Exception, e: import traceback print "Could not stop state machine: {0} {1}".format( e.message, traceback.format_exc())
def get_models(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.gui.models.container_state import ContainerStateModel def get_outcome_with_name(state_m, outcome_name): return [ outcome_m for outcome_m in state_m.outcomes if outcome_m.outcome.name == outcome_name ][0] def get_state_with_name(parent_state_m, state_name): return [ state_m for state_m in parent_state_m.states.values() if state_m.state.name == state_name ][0] execution_state = ExecutionState("ex1") execution_state.add_outcome("oe1") child_state = ExecutionState("ex2") hierarchy_state = HierarchyState("h1") hierarchy_state.add_outcome("oh1") hierarchy_state.add_state(child_state) root_state = HierarchyState("root") root_state.add_state(execution_state) root_state.add_state(hierarchy_state) root_state_m = ContainerStateModel(root_state) execution_state_m = get_state_with_name(root_state_m, "ex1") hierarchy_state_m = get_state_with_name(root_state_m, "h1") child_state_m = get_state_with_name(hierarchy_state_m, "ex2") outcome_e_success_m = get_outcome_with_name(execution_state_m, "success") outcome_e_1_m = get_outcome_with_name(execution_state_m, "oe1") outcome_h_success_m = get_outcome_with_name(hierarchy_state_m, "success") outcome_h_1_m = get_outcome_with_name(hierarchy_state_m, "oh1") return (root_state_m, execution_state_m, hierarchy_state_m, child_state_m), (outcome_e_success_m, outcome_e_1_m), \ (outcome_h_success_m, outcome_h_1_m)
def test_save_libraries(caplog): s = storage state1 = ExecutionState("library_execution_state1", path=testing_utils.TEST_SCRIPT_PATH, filename="library_execution_state1.py") input_state1 = state1.add_input_data_port("data_input_port1", "float") output_state1 = state1.add_output_data_port("data_output_port1", "float") state2 = ExecutionState("library_execution_state2", path=testing_utils.TEST_SCRIPT_PATH, filename="library_execution_state2.py") input_state2 = state2.add_input_data_port("data_input_port1", "float") output_state2 = state2.add_output_data_port("data_output_port1", "float") state3 = HierarchyState("library_hierarchy_state1") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_transition(state1.state_id, 0, state2.state_id, None) state3.add_transition(state2.state_id, 0, state3.state_id, 0) input_state3 = state3.add_input_data_port("data_input_port1", "float", 1.0) output_state3 = state3.add_output_data_port("data_output_port1", "float", 2.0) state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state1.state_id, output_state1, state2.state_id, input_state2) state3.add_data_flow(state2.state_id, output_state2, state3.state_id, output_state3) # save hierarchy state as state machine s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "hierarchy_library")) # save execution state as state machine s.save_state_machine_to_path(StateMachine(state1), join(TEST_LIBRARY_PATH, "execution_library")) # save hierarchy state as nested state machines state3.name = "library_nested1" s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "library_container", "library_nested1"), delete_old_state_machine=True) state3.name = "library_nested2" s.save_state_machine_to_path(StateMachine(state3), join(TEST_LIBRARY_PATH, "library_container", "library_nested2"), delete_old_state_machine=True) testing_utils.assert_logger_warnings_and_errors(caplog)
def test_state_machine_manager(caplog): state_machine = StateMachine() state1 = ExecutionState("s1") state_machine.root_state = state1 manager = StateMachineManager.instance([state_machine]) sm_id = manager.get_sm_id_for_root_state_id('FakeId') assert (sm_id is None) assert_logger_warnings_and_errors(caplog)
def create_state_machine(): state1 = ExecutionState("MyFirstState", state_id="FirstLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "str", "default_value") output_state1 = state1.add_output_data_port("output_data_port1", "str") state2 = HierarchyState("MyFirstHierarchyState", state_id="FirstLevel1") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_outcome("Container_Outcome", 6) state2.add_transition(state1.state_id, 3, state2.state_id, 6) input_state2 = state2.add_input_data_port("input_data_port1", "str") output_state2 = state2.add_output_data_port("output_data_port1", "str") # state2.add_data_flow(state2.state_id, # input_state2, # state1.state_id, # input_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) return StateMachine(state2)
def test_lock_state_machine(caplog): state_machine = StateMachine() @lock_state_machine def custom_function(object, number): raise AttributeError("Test error") State.custom_method = custom_function state1 = ExecutionState("s1") state_machine.root_state = state1 try: state1.custom_method(5) except Exception as e: import traceback print("Could not stop state machine: {0} {1}".format( e, traceback.format_exc())) assert global_lock_counter == 0 state1.add_outcome("outcome1", 3) assert len(state1.outcomes) == 4 assert_logger_warnings_and_errors(caplog)
def create_state_machine(): state1 = ExecutionState("scoped_data_test_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_variable_test_state.py") state1.add_outcome("loop", 1) input1_state1 = state1.add_input_data_port("input_data_port1", "float") input2_state1 = state1.add_input_data_port("input_data_port2", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state2 = HierarchyState("scoped_data_hierarchy_state") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_transition(state1.state_id, 0, state2.state_id, 0) state2.add_transition(state1.state_id, 1, state1.state_id, None) input_state2 = state2.add_input_data_port("input_data_port1", "float", 10.0) output_state2 = state2.add_output_data_port("output_data_port1", "float") scoped_variable_state2 = state2.add_scoped_variable( "scoped_variable1", "float", 12.0) state2.add_data_flow( state2.state_id, state2.get_scoped_variable_from_name("scoped_variable1"), state1.state_id, input1_state1) state2.add_data_flow(state2.state_id, input_state2, state1.state_id, input2_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, scoped_variable_state2) return StateMachine(state2)
def create_models_concurrency(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.barrier_concurrency_state import BarrierConcurrencyState from rafcon.core.states.preemptive_concurrency_state import PreemptiveConcurrencyState from rafcon.core.states.hierarchy_state import HierarchyState [state, sm_model, state_dict] = create_models() pstate = PreemptiveConcurrencyState(name='Preemptive', state_id='PREEMPT') state_dict['Nested'].add_state(pstate) state_dict['Preemptive'] = pstate hstate = HierarchyState() estate = ExecutionState() estate.script_text = estate.script_text + "\nprint 'nochwas'" state_dict['Preemptive'].add_state(hstate) state_dict['Preemptive'].add_state(estate) bstate = BarrierConcurrencyState(name='Barrier', state_id='BARRIER') state_dict['Nested'].add_state(bstate) state_dict['Barrier'] = bstate hstate = HierarchyState() estate = ExecutionState() estate.script_text = estate.script_text + "\nprint 'irgendwas'" state_dict['Barrier'].add_state(hstate) state_dict['Barrier'].add_state(estate) return state, sm_model, state_dict
def create_state_machine(): from rafcon.core.state_machine import StateMachine from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState root = HierarchyState(name='root') ex1 = ExecutionState(name='1') root.add_state(ex1) ex2 = ExecutionState(name='2') root.add_state(ex2) ex3 = ExecutionState(name='3') root.add_state(ex3) # hierarchy state at the beginning h4 = HierarchyState('H4') ex41 = ExecutionState(name='41') h4.add_state(ex41) ex42 = ExecutionState(name='42') h4.add_state(ex42) ex43 = ExecutionState(name='43') h4.add_state(ex43) h4.start_state_id = ex41.state_id h4.add_transition(ex41.state_id, 0, ex42.state_id, None) h4.add_transition(ex42.state_id, 0, ex43.state_id, None) h4.add_transition(ex43.state_id, 0, h4.state_id, 0) root.add_state(h4) root.start_state_id = ex1.state_id root.add_transition(h4.state_id, 0, ex1.state_id, None) root.add_transition(ex1.state_id, 0, ex2.state_id, None) root.add_transition(ex2.state_id, 0, ex3.state_id, None) t_id = root.add_transition(ex3.state_id, 0, root.state_id, 0) return StateMachine(root_state=root), t_id, h4.state_id
def return_loop_state_machine(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state1.py") state1.add_outcome("MyFirstOutcome", 3) state2 = ExecutionState("MySecondState", path=testing_utils.TEST_SCRIPT_PATH, filename="loop_state2.py") state2.add_outcome("FirstOutcome", 3) state3 = HierarchyState("MyFirstHierarchyState") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_transition(state1.state_id, 3, state2.state_id, None) state3.add_transition(state2.state_id, 3, state1.state_id, None) return StateMachine(state3)
def test_default(): testing_utils.dummy_gui(None) from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.gui.models.container_state import ContainerStateModel parent_state = HierarchyState() parent_state_m = ContainerStateModel(parent_state) child_state_a = ExecutionState("A") parent_state.add_state(child_state_a) assert len(parent_state_m.states) == 1 child_state_a_m = list(parent_state_m.states.values())[0] assert child_state_a_m.core_element is child_state_a
def create_preemptive_wait_state_machine(): state1 = ExecutionState("state_1", path=testing_utils.TEST_SCRIPT_PATH, filename="preemptive_wait_test.py") state1.add_outcome("FirstOutcome", 3) state2 = ExecutionState("state_2", path=testing_utils.TEST_SCRIPT_PATH, filename="preemptive_wait_test.py") state2.add_outcome("FirstOutcome", 3) ctr_state = PreemptiveConcurrencyState("FirstConcurrencyState") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_outcome("end", 3) ctr_state.add_transition(state1.state_id, 3, ctr_state.state_id, 3) ctr_state.add_transition(state2.state_id, 3, ctr_state.state_id, 3) return StateMachine(ctr_state)
def create_state_machine(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="global_variable_state.py") state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state3 = HierarchyState("MyFirstHierarchyState") state3.add_state(state1) state3.set_start_state(state1.state_id) state3.add_outcome("Container_Outcome", 6) state3.add_transition(state1.state_id, 3, state3.state_id, 6) input_state3 = state3.add_input_data_port("input_data_port1", "float", 22.0) output_state3 = state3.add_output_data_port("output_data_port1", "float") state3.add_data_flow(state3.state_id, input_state3, state1.state_id, input_state1) state3.add_data_flow(state1.state_id, output_state1, state3.state_id, output_state3) return StateMachine(state3)
def create_concurrency_barrier_state(): state1 = ExecutionState("FirstState", "id_of_state_1", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrency_barrier1.py") state1.add_outcome("FirstOutcomeState1", 3) state1.add_outcome("SecondOutcomeState1", 4) input_state1 = state1.add_input_data_port("input_data_port1", "float") output_state1 = state1.add_output_data_port("output_data_port1", "float") state2 = ExecutionState("SecondState", "id_of_state_2", path=testing_utils.TEST_SCRIPT_PATH, filename="concurrency_barrier2.py") state2.add_outcome("FirstOutcomeState2", 3) state2.add_outcome("SecondOutcomeState2", 4) input_state2 = state2.add_input_data_port("input_data_port1", "float") output_state2 = state2.add_output_data_port("output_data_port1", "float") barrier_state = BarrierConcurrencyState("FirstConcurrencyState", "barrier_state_id") barrier_state.add_state(state1) barrier_state.add_state(state2) input1_state3 = barrier_state.add_input_data_port("input_data_port1", "float", 0.1) input2_state3 = barrier_state.add_input_data_port("input_data_port2", "float", 0.1) barrier_state.add_data_flow(barrier_state.state_id, input1_state3, state1.state_id, input_state1) barrier_state.add_data_flow(barrier_state.state_id, input2_state3, state2.state_id, input_state2) barrier_state.add_output_data_port("output_data_port1", "str", "default_output_value") barrier_state.add_outcome("success_outcome", 3) barrier_state.add_outcome("error_outcome", 4) barrier_state.states[UNIQUE_DECIDER_STATE_ID].name = "decider_state" barrier_state.states[UNIQUE_DECIDER_STATE_ID]._script = Script(path=testing_utils.TEST_SCRIPT_PATH, filename="decider_state.py", check_path=True, parent=barrier_state.states[UNIQUE_DECIDER_STATE_ID]) barrier_state.states[UNIQUE_DECIDER_STATE_ID].add_outcome("FirstOutcomeDecider", 3) barrier_state.states[UNIQUE_DECIDER_STATE_ID].add_outcome("SecondOutcomeDecider", 4) barrier_state.add_transition(barrier_state.states[UNIQUE_DECIDER_STATE_ID].state_id, 3, barrier_state.state_id, 3) barrier_state.add_transition(barrier_state.states[UNIQUE_DECIDER_STATE_ID].state_id, 4, barrier_state.state_id, 4) return barrier_state
def create_state_machine2(): state1 = ExecutionState("MyFirstState", state_id="FirstLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state0 = ExecutionState("MyZeroState", state_id="ZeroLevel2", path=testing_utils.TEST_SCRIPT_PATH, filename="default_data_port_test_state.py") state0.add_outcome("first_outcome", 3) input_state0 = state0.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1) output_state0 = state0.add_output_data_port("output_data_port1", tuple) state1.add_outcome("first_outcome", 3) input_state1 = state1.add_input_data_port("input_data_port1", tuple, (1, 3, 2), data_port_id=1) output_state1 = state1.add_output_data_port("output_data_port1", tuple) state2 = HierarchyState("MyFirstHierarchyState",state_id="FirstLevel1") state2.add_state(state1) state2.add_state(state0) state2.set_start_state(state0.state_id) state2.add_outcome("Container_Outcome", 6) state2.add_transition(state0.state_id, 3, state1.state_id, None) state2.add_transition(state1.state_id, 3, state2.state_id, 6) input_state2 = state2.add_input_data_port("input_data_port1", tuple) output_state2 = state2.add_output_data_port("output_data_port1", tuple) state2.add_data_flow(state0.state_id, output_state0, state1.state_id, input_state1) state2.add_data_flow(state1.state_id, output_state1, state2.state_id, output_state2) return StateMachine(state2)
def test_unique_port_names(caplog): state = ExecutionState('execution state') state.add_input_data_port("in", "int", 0) state.add_output_data_port("out", "int", 0) # Data port name must be unique within data port set (input or output) with raises(ValueError): state.add_input_data_port("in", "int", 0) with raises(ValueError): state.add_input_data_port("in", "double", 0) with raises(ValueError): state.add_output_data_port("out", "int", 0) with raises(ValueError): state.add_output_data_port("out", "double", 0) # Names are allowed for other data port set state.add_output_data_port("in", "int", 0) state.add_input_data_port("out", "int", 0) assert len(state.input_data_ports) == 2 assert len(state.output_data_ports) == 2 state = HierarchyState('hierarchy state') in_id = state.add_input_data_port("in", "int", 0) out_id = state.add_output_data_port("out", "int", 0) scope_id = state.add_scoped_variable("scope", "int", 0) # Data port name must be unique within data port set (input, output or scope) with raises(ValueError): state.add_input_data_port("in", "int", 0) with raises(ValueError): state.add_input_data_port("in", "double", 0) with raises(ValueError): state.add_output_data_port("out", "int", 0) with raises(ValueError): state.add_output_data_port("out", "double", 0) with raises(ValueError): state.add_scoped_variable("scope", "int", 0) with raises(ValueError): state.add_scoped_variable("scope", "double", 0) # check programmatic direct data_type and default_value usage DataPort-Class state.add_input_data_port("_in", int, 0) list_op_id = state.add_output_data_port("_out", list, [1, 2, 3]) with raises(TypeError): state.add_scoped_variable("_scope", float, 0) with raises(TypeError): state.output_data_ports[list_op_id].default_value = (1, 3) # Names are allowed for other data port set state.add_output_data_port("in", "int", 0) state.add_scoped_variable("in", "int", 0) state.add_input_data_port("out", "int", 0) state.add_scoped_variable("out", "int", 0) state.add_input_data_port("scope", "int", 0) state.add_output_data_port("scope", "int", 0) # Also renaming should raise exceptions with raises(ValueError): state.input_data_ports[in_id].name = "out" with raises(ValueError): state.output_data_ports[out_id].name = "in" with raises(ValueError): state.scoped_variables[scope_id].name = "out" assert len(state.input_data_ports) == 4 assert len(state.output_data_ports) == 4 assert len(state.scoped_variables) == 3 testing_utils.assert_logger_warnings_and_errors(caplog)