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_state_machine(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine print("create models") logger.setLevel(logging.VERBOSE) for handler in logging.getLogger('gtkmvc3').handlers: logging.getLogger('gtkmvc3').removeHandler(handler) state1 = ExecutionState('State1', state_id='STATE1') output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2', state_id='STATE2') input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested', state_id='NESTED') state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2', state_id='NESTED2') state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id='STATE3') input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') ctr_state = HierarchyState(name="Container", state_id='CONT2') ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.name = "Container" ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable2_ctr_state = ctr_state.add_scoped_variable( "my_var", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) state_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) return sm
path_core_data = os.path.join(state_path, FILE_NAME_CORE_DATA_OLD) try: state_info = load_data_file(path_core_data) except ValueError, e: logger.exception("Error while loading state data: {0}".format(e)) return except LibraryNotFoundException, e: logger.error( "Library could not be loaded: {0}\n" "Skipping library and continuing loading the state machine".format( str(e.message))) state_info = storage_utils.load_objects_from_json(path_core_data, as_dict=True) state_id = state_info["state_id"] dummy_state = HierarchyState(LIBRARY_NOT_FOUND_DUMMY_STATE_NAME, state_id=state_id) # set parent of dummy state if isinstance(parent, ContainerState): parent.add_state(dummy_state, storage_load=True) else: dummy_state.parent = parent return dummy_state # Transitions and data flows are not added when loading a state, as also states are not added. # We have to wait until the child states are loaded, before adding transitions and data flows, as otherwise the # validity checks for transitions and data flows would fail if not isinstance(state_info, tuple): state = state_info else: state = state_info[0] transitions = state_info[1]
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 load_state_recursively(parent, state_path=None, dirty_states=[]): """Recursively loads the state It calls this method on each sub-state of a container state. :param parent: the root state of the last load call to which the loaded state will be added :param state_path: the path on the filesystem where to find the meta file for the state :param dirty_states: a dict of states which changed during loading :return: """ from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.container_state import ContainerState from rafcon.core.states.hierarchy_state import HierarchyState path_core_data = os.path.join(state_path, FILE_NAME_CORE_DATA) logger.debug("Load state recursively: {0}".format(str(state_path))) # TODO: Should be removed with next minor release if not os.path.exists(path_core_data): path_core_data = os.path.join(state_path, FILE_NAME_CORE_DATA_OLD) try: state_info = load_data_file(path_core_data) except ValueError as e: logger.exception("Error while loading state data: {0}".format(e)) return except LibraryNotFoundException as e: logger.error( "Library could not be loaded: {0}\n" "Skipping library and continuing loading the state machine".format( e)) state_info = storage_utils.load_objects_from_json(path_core_data, as_dict=True) state_id = state_info["state_id"] dummy_state = HierarchyState(LIBRARY_NOT_FOUND_DUMMY_STATE_NAME, state_id=state_id) # set parent of dummy state if isinstance(parent, ContainerState): parent.add_state(dummy_state, storage_load=True) else: dummy_state.parent = parent return dummy_state # Transitions and data flows are not added when loading a state, as also states are not added. # We have to wait until the child states are loaded, before adding transitions and data flows, as otherwise the # validity checks for transitions and data flows would fail if not isinstance(state_info, tuple): state = state_info else: state = state_info[0] transitions = state_info[1] data_flows = state_info[2] # set parent of state if parent is not None and isinstance(parent, ContainerState): parent.add_state(state, storage_load=True) else: state.parent = parent # read script file if an execution state if isinstance(state, ExecutionState): script_text = read_file(state_path, state.script.filename) state.script_text = script_text # load semantic data try: semantic_data = load_data_file( os.path.join(state_path, SEMANTIC_DATA_FILE)) state.semantic_data = semantic_data except Exception as e: # semantic data file does not have to be there pass one_of_my_child_states_not_found = False # load child states for p in os.listdir(state_path): child_state_path = os.path.join(state_path, p) if os.path.isdir(child_state_path): child_state = load_state_recursively(state, child_state_path, dirty_states) if not child_state: return None if child_state.name is LIBRARY_NOT_FOUND_DUMMY_STATE_NAME: one_of_my_child_states_not_found = True if one_of_my_child_states_not_found: # omit adding transitions and data flows in this case pass else: # Now we can add transitions and data flows, as all child states were added if isinstance(state_info, tuple): state.transitions = transitions state.data_flows = data_flows state.file_system_path = state_path if state.marked_dirty: dirty_states.append(state) return state
def create_execution_state_library_state_machine(): rafcon.core.singleton.library_manager.initialize() library_container_state = HierarchyState("libContainerState", state_id="libContainerState") lib_state = LibraryState("temporary_libraries", "execution_library", "0.1", "library_execution_state", state_id="library_execution_state") library_container_state.add_state(lib_state) library_container_state.set_start_state(lib_state.state_id) library_container_state.add_transition(lib_state.state_id, 0, library_container_state.state_id, 0) lib_container_input = library_container_state.add_input_data_port( "data_input_port1", "float", 32.0) lib_container_output = library_container_state.add_output_data_port( "data_output_port1", "float") library_container_state.add_data_flow( library_container_state.state_id, lib_container_input, lib_state.state_id, lib_state.get_io_data_port_id_from_name_and_type( "data_input_port1", InputDataPort)) library_container_state.add_data_flow( lib_state.state_id, lib_state.get_io_data_port_id_from_name_and_type( "data_output_port1", OutputDataPort), library_container_state.state_id, lib_container_output) return StateMachine(library_container_state)
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', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) root.add_state(ex1) ex2 = ExecutionState(name='2', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) root.add_state(ex2) ex3 = ExecutionState(name='3', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) root.add_state(ex3) # hierarchy state at the beginning h4 = HierarchyState('H4') ex41 = ExecutionState(name='41', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) h4.add_state(ex41) ex42 = ExecutionState(name='42', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) h4.add_state(ex42) ex43 = ExecutionState(name='43', filename="script_small_wait.py", path=TEST_SCRIPT_PATH) 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 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)
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 create_new_state_machine(): root_state = HierarchyState() state_machine = StateMachine(root_state) core_singletons.state_machine_manager.add_state_machine(state_machine)
def create_state_machine(): state1 = ExecutionState("DummyState1", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state1.add_outcome('dummy_outcome_1', 3) state1.add_outcome('dummy_outcome_2', 4) state2 = ExecutionState("DummyState2", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state2.add_outcome('dummy_outcome_1', 3) state2.add_outcome('dummy_outcome_2', 4) state3 = ExecutionState("DummyState3", path=testing_utils.TEST_SCRIPT_PATH, filename="transition_test_state.py") state3.add_outcome('dummy_outcome_1', 3) state3.add_outcome('dummy_outcome_2', 4) state4 = HierarchyState("DummyHierarchyState") state4.add_state(state1) state4.set_start_state(state1.state_id) state4.add_state(state2) state4.add_state(state3) state4.add_outcome("final_outcome", 5) state4.add_transition(state1.state_id, 3, state2.state_id, None) state4.add_transition(state1.state_id, 4, state3.state_id, None) state4.add_transition(state2.state_id, 3, state4.state_id, 5) state4.add_transition(state3.state_id, 3, state4.state_id, 5) state4.add_transition(state3.state_id, 4, state4.state_id, 5) t = state4.add_transition(state2.state_id, 4, state1.state_id, None) state4.remove_transition(t) state4.add_transition(state2.state_id, 4, state1.state_id, None) # no target at all with raises(ValueError): state4.add_transition(state3.state_id, 4, None, None) # no to_state with raises(ValueError): state4.add_transition(state3.state_id, 4, None, 5) # start transition already existing with raises(ValueError): state4.add_transition(None, None, state3.state_id, None) state4.start_state_id = None state4.add_transition(None, None, state1.state_id, None) return StateMachine(state4)
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
def test_add_remove_history(caplog): testing_utils.dummy_gui(None) ################## # Root_state elements # add state # - change state # remove state # add outcome # - change outcome # remove outcome # add transition # - change transition # remove transition # add input_data_port # - change input_data_port # remove input_data_port # add output_data_port # - change output_data_port # remove output_data_port # add scoped_variable # - change scoped_variable # remove scoped_variable # add data_flow # - change data_flow # remove data_flow 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() state_machine_path = TEST_PATH + '_test_add_remove' save_state_machine(state_machine_m, state_machine_path + '_before', logger, with_gui=False, menubar_ctrl=None) sm_history = state_machine_m.history state1 = HierarchyState('state1', state_id='STATE1') state2 = ExecutionState('state2', state_id='STATE2') state_dict['Nested'].add_state(state1) state_dict['Nested'].add_state(state2) state_dict['state1'] = state1 state_dict['state2'] = state2 state_path_dict = {} for key in state_dict: state_path_dict[key] = state_dict[key].get_path() def do_check_for_state(state_name): sm_history.modifications.reset() # Note: The elements always need to be retrieved before performing an operation, as undo/redo operations replace # both core and model objects state_m = get_state_model_by_name(state_name, state_path_dict) ############# # outcome add & remove outcome_super, state = perform_history_action(state_m.state.add_outcome, "super") state = get_state_by_name(state_name, state_path_dict) _, state = perform_history_action(state_m.state.remove_outcome, outcome_super) ############# # add two states state4 = ExecutionState('State4', state_id='STATE4') state_path_dict['state4'] = state.get_path() + "/" + "STATE4" _, state = perform_history_action(state.add_state, state4) state5 = ExecutionState('State5', state_id='STATE5') state_path_dict['state5'] = state.get_path() + "/" + "STATE5" _, state = perform_history_action(state.add_state, state5) perform_multiple_undo_redo(2) state4 = get_state_by_name('state4', state_path_dict) outcome_state4 = state4.add_outcome('UsedHere') assert len(sm_history.modifications) == 6 state5 = get_state_by_name('state5', state_path_dict) outcome_state5 = state5.add_outcome('UsedHere') assert len(sm_history.modifications) == 7 ################ # add transition from_state_id, from_outcome, to_state_id=None, to_outcome=None, transition_id new_transition_id1, state = perform_history_action(state.add_transition, from_state_id=state4.state_id, from_outcome=outcome_state4, to_state_id=state5.state_id, to_outcome=None) _, state = perform_history_action(state.add_transition, from_state_id=state5.state_id, from_outcome=outcome_state5, to_state_id=state.state_id, to_outcome=-1) ################### # remove transition _, state = perform_history_action(state.remove_transition, new_transition_id1) ############# # remove state _, state = perform_history_action(state.remove_state, state5.state_id) ############# # add input_data_port state4 = get_state_by_name('state4', state_path_dict) input_state4_id, state4 = perform_history_action(state4.add_input_data_port, "input", "str", "zero") ############# # remove input_data_port _, state4 = perform_history_action(state4.remove_input_data_port, input_state4_id) ############# # add output_data_port output_state4_id, state4 = perform_history_action(state4.add_output_data_port, "output_"+state4.state_id, "int") ############# # remove output_data_port _, state4 = perform_history_action(state4.remove_output_data_port, output_state4_id) # prepare again state4 state4.add_output_data_port("output", "int") state4.add_input_data_port("input_new", "str", "zero") assert len(sm_history.modifications) == 17 output_state4_id = state4.add_output_data_port("output_new", "int") assert len(sm_history.modifications) == 18 state5 = ExecutionState('State5', 'STATE5') state = get_state_by_name(state_name, state_path_dict) state.add_state(state5) assert state_path_dict['state5'] == state5.get_path() assert len(sm_history.modifications) == 19 input_par_state5 = state5.add_input_data_port("par", "int", 0) assert len(sm_history.modifications) == 20 output_res_state5 = state5.add_output_data_port("res", "int") assert len(sm_history.modifications) == 21 ##################### # add scoped_variable scoped_buffer_nested, state = perform_history_action(state.add_scoped_variable, "buffer", "int") ##################### # remove scoped_variable _, state = perform_history_action(state.remove_scoped_variable, scoped_buffer_nested) ############# # add data_flow new_df_id, state = perform_history_action(state.add_data_flow, from_state_id=state4.state_id, from_data_port_id=output_state4_id, to_state_id=state5.state_id, to_data_port_id=input_par_state5) ################ # remove data_flow perform_history_action(state.remove_data_flow, new_df_id) do_check_for_state(state_name='Nested') do_check_for_state(state_name='Container') testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def create_state_machine(): state1 = ExecutionState("first_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_data_test_state1.py") state1.add_outcome("first_outcome", 3) state1.add_input_data_port("data_input_port1", "float") state1.add_output_data_port("data_output_port1", "float") state2 = ExecutionState("second_state", path=testing_utils.TEST_SCRIPT_PATH, filename="scoped_data_test_state2.py") state2.add_outcome("first_outcome", 3) state2.add_input_data_port("data_input_port1", "float") state2.add_output_data_port("data_output_port1", "float") state3 = HierarchyState("hierarchy_state") state3.add_state(state1) state3.add_state(state2) state3.set_start_state(state1.state_id) state3.add_outcome("Container_Outcome", 6) state3.add_transition(state1.state_id, 3, state2.state_id, None) state3.add_transition(state2.state_id, 3, state3.state_id, 6) state3.add_input_data_port("data_input_port1", "float", 22.0) state3.add_output_data_port("data_output_port1", "float") state3.add_data_flow( state3.state_id, state3.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort), state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state3.add_data_flow( state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort), state2.state_id, state2.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state3.add_data_flow( state2.state_id, state2.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort), state3.state_id, state3.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort)) return StateMachine(state3)
def load_state_recursively(parent, state_path=None, dirty_states=[]): """Recursively loads the state It calls this method on each sub-state of a container state. :param parent: the root state of the last load call to which the loaded state will be added :param state_path: the path on the filesystem where to find the meta file for the state :param dirty_states: a dict of states which changed during loading :return: """ from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.container_state import ContainerState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.singleton import library_manager path_core_data = get_core_data_path(state_path) path_meta_data = get_meta_data_path(state_path) logger.debug("Load state recursively: {0}".format(str(state_path))) try: state_info = load_data_file(path_core_data) except ValueError as e: logger.exception("Error while loading state data: {0}".format(e)) return except LibraryNotFoundException as e: if global_config.get_config_value( "RAISE_ERROR_ON_MISSING_LIBRARY_STATES", False) or not library_manager.show_dialog: raise logger.error( "Library could not be loaded: {0}\n" "Skipping library and continuing loading the state machine".format( e)) state_info = storage_utils.load_objects_from_json(path_core_data, as_dict=True) missing_library_meta_data = None if os.path.exists(path_meta_data): missing_library_meta_data = Vividict( storage_utils.load_objects_from_json(path_meta_data)) state_id = state_info["state_id"] outcomes = { outcome['outcome_id']: Outcome(outcome['outcome_id'], outcome['name']) for outcome in state_info["outcomes"].values() } dummy_state = HierarchyState( LIBRARY_NOT_FOUND_DUMMY_STATE_NAME, state_id=state_id, outcomes=outcomes, is_dummy=True, missing_library_meta_data=missing_library_meta_data) library_name = state_info['library_name'] path_parts = os.path.join(state_info['library_path'], library_name).split(os.sep) dummy_state.description = 'The Missing Library Path: %s\nThe Missing Library Name: %s\n\n' % ( state_info['library_path'], library_name) from rafcon.core.singleton import library_manager if path_parts[0] in library_manager.library_root_paths: dummy_state.description += 'The Missing Library OS Path: %s' % os.path.join( library_manager.library_root_paths[path_parts[0]], * path_parts[1:]) else: dummy_state.description += 'The missing library was located in the missing library root "%s"' % path_parts[ 0] # set parent of dummy state if isinstance(parent, ContainerState): parent.add_state(dummy_state, storage_load=True) else: dummy_state.parent = parent return dummy_state except LibraryNotFoundSkipException: return None # Transitions and data flows are not added when loading a state, as also states are not added. # We have to wait until the child states are loaded, before adding transitions and data flows, as otherwise the # validity checks for transitions and data flows would fail if not isinstance(state_info, tuple): state = state_info else: state = state_info[0] transitions = state_info[1] data_flows = state_info[2] # set parent of state if parent is not None and isinstance(parent, ContainerState): parent.add_state(state, storage_load=True) else: state.parent = parent # read script file if state is an ExecutionState if isinstance(state, ExecutionState): script_text = read_file(state_path, state.script.filename) state.script.set_script_without_compilation(script_text) # load semantic data try: semantic_data = load_data_file( os.path.join(state_path, SEMANTIC_DATA_FILE)) state.semantic_data = semantic_data except Exception as e: # semantic data file does not have to be there pass # load child states for p in os.listdir(state_path): child_state_path = os.path.join(state_path, p) if os.path.isdir(child_state_path): if not os.path.exists( os.path.join(child_state_path, FILE_NAME_CORE_DATA)): # this means that child_state_path is a folder, not containing a valid state # this also happens when pip creates __pycache__ folders for the script.py files upon installing rafcon continue child_state = load_state_recursively(state, child_state_path, dirty_states) if not child_state: return None # Now we can add transitions and data flows, as all child states were added if isinstance(state_info, tuple): safe_init = global_config.get_config_value("LOAD_SM_WITH_CHECKS", True) if safe_init: # this will trigger all validity checks the state machine state.transitions = transitions else: state._transitions = transitions state._data_flows = data_flows for _, transition in state.transitions.items(): transition._parent = ref(state) state._data_flows = data_flows for _, data_flow in state.data_flows.items(): data_flow._parent = ref(state) state.file_system_path = state_path if state.marked_dirty: dirty_states.append(state) return state
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" return StateMachine(ctr_state)
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)
def add_state_machine(widget, event=None): """Create a new state-machine when the user clicks on the '+' next to the tabs""" logger.debug("Creating new state-machine...") root_state = HierarchyState("new root state") state_machine = StateMachine(root_state) rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
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_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 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 create_hierarchy_state(): state1 = ExecutionState("MyFirstState", path=testing_utils.TEST_SCRIPT_PATH, filename="first_execution_state.py") state1.add_outcome("MyFirstOutcome", 3) state1.add_input_data_port("data_input_port1", "float") state1.add_output_data_port("faulty_output_port", "float") state1.add_output_data_port("data_output_port1", "float") state2 = HierarchyState("MyFirstHierarchyState") state2.add_state(state1) state2.set_start_state(state1.state_id) state2.add_outcome("Container_Outcome", 6) transition_id = state2.add_transition(state1.state_id, 3, state2.state_id, 6) # print state2.transitions[transition_id] input_data_port_id = state2.add_input_data_port("input1", "float", 42.0, data_port_id=42) state2.add_output_data_port("output1", "float") state2.add_data_flow( state2.state_id, state2.get_io_data_port_id_from_name_and_type("input1", InputDataPort), state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_input_port1", InputDataPort)) state2.add_data_flow( state1.state_id, state1.get_io_data_port_id_from_name_and_type("data_output_port1", OutputDataPort), state2.state_id, state2.get_io_data_port_id_from_name_and_type("output1", OutputDataPort)) return state2
def create_state_machine(): from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1', state_id="State1") output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2', state_id="State2") input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested', state_id="Nested") state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2', state_id="Nested2") state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3', state_id="State3") input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') # print state3.input_data_ports # print state3.output_data_ports # exit(0) ctr_state = HierarchyState(name="Root", state_id="Root") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") #print input_ctr_state output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") #print output_ctr_state 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.name = "Container" ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") # print ctr_state.input_data_ports # print ctr_state.output_data_ports # exit(0) scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable2_ctr_state = ctr_state.add_scoped_variable( "my_var", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) tmp_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) return tmp_dict, sm
def create_models(): import rafcon.core.singleton from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.state_machine import StateMachine state1 = ExecutionState('State1') output_state1 = state1.add_output_data_port("output", "int") input_state1 = state1.add_input_data_port("input", "str", "zero") state2 = ExecutionState('State2') input_par_state2 = state2.add_input_data_port("par", "int", 0) output_res_state2 = state2.add_output_data_port("res", "int") state4 = HierarchyState(name='Nested') state4.add_outcome('GoGo') output_state4 = state4.add_output_data_port("out", "int") state5 = ExecutionState('Nested2') state5.add_outcome('HereWeGo') input_state5 = state5.add_input_data_port("in", "int", 0) state3 = HierarchyState(name='State3') input_state3 = state3.add_input_data_port("input", "int", 0) output_state3 = state3.add_output_data_port("output", "int") 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) state3.add_outcome('Branch1') state3.add_outcome('Branch2') ctr_state = HierarchyState(name="Container") ctr_state.add_state(state1) ctr_state.add_state(state2) ctr_state.add_state(state3) input_ctr_state = ctr_state.add_input_data_port("ctr_in", "str", "zero") output_ctr_state = ctr_state.add_output_data_port("ctr_out", "int") 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.add_data_flow(state1.state_id, output_state1, state2.state_id, input_par_state2) ctr_state.add_data_flow(state2.state_id, output_res_state2, state3.state_id, input_state3) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, state1.state_id, input_state1) ctr_state.add_data_flow(state3.state_id, output_state3, ctr_state.state_id, output_ctr_state) ctr_state.add_input_data_port("input", "str", "default_value1") ctr_state.add_input_data_port("pos_x", "str", "default_value2") ctr_state.add_input_data_port("pos_y", "str", "default_value3") ctr_state.add_output_data_port("output", "str", "default_value1") ctr_state.add_output_data_port("result", "str", "default_value2") scoped_variable1_ctr_state = ctr_state.add_scoped_variable( "scoped", "str", "default_value1") scoped_variable2_ctr_state = ctr_state.add_scoped_variable( "my_var", "str", "default_value1") scoped_variable3_ctr_state = ctr_state.add_scoped_variable( "ctr", "int", 42) ctr_state.add_data_flow(ctr_state.state_id, input_ctr_state, ctr_state.state_id, scoped_variable1_ctr_state) ctr_state.add_data_flow(state1.state_id, output_state1, ctr_state.state_id, scoped_variable3_ctr_state) state_dict = { 'Container': ctr_state, 'State1': state1, 'State2': state2, 'State3': state3, 'Nested': state4, 'Nested2': state5 } sm = StateMachine(ctr_state) rafcon.core.singleton.state_machine_manager.add_state_machine(sm) testing_utils.wait_for_gui() state_machine_model = rafcon.gui.singleton.state_machine_manager_model.state_machines[ sm.state_machine_id] return ctr_state, state_machine_model, state_dict
def create_turtle_statemachine(base_path, example_path): basic_turtle_demo_state = HierarchyState("BasicTurtleDemo") init_ros_node = LibraryState("ros_libraries", "init_ros_node", "0.1", "init ros node") basic_turtle_demo_state.add_state(init_ros_node) basic_turtle_demo_state.set_start_state(init_ros_node.state_id) ######################################################## # Turtle Concurrency State ######################################################## preemptive_concurrency_state = PreemptiveConcurrencyState( "Turtle Concurrency State") basic_turtle_demo_state.add_state(preemptive_concurrency_state) basic_turtle_demo_state.add_transition( init_ros_node.state_id, 0, preemptive_concurrency_state.state_id, None) basic_turtle_demo_state.add_transition( preemptive_concurrency_state.state_id, 0, basic_turtle_demo_state.state_id, 0) ######################################################## # Subscribe to turtle position concurrency State ######################################################## subscribe_to_turtle_position_hierarchy_state = HierarchyState( "Turtle Position Subscriber Hierarchy State") preemptive_concurrency_state.add_state( subscribe_to_turtle_position_hierarchy_state) spawn_turtle = LibraryState("turtle_libraries", "turtle_position_subscriber", "0.1", "subscribe to turtle position") subscribe_to_turtle_position_hierarchy_state.add_state(spawn_turtle) subscribe_to_turtle_position_hierarchy_state.set_start_state( spawn_turtle.state_id) subscribe_to_turtle_position_hierarchy_state.add_transition( spawn_turtle.state_id, 0, spawn_turtle.state_id, None) ######################################################## # Move Turtle Hierarchy State ######################################################## move_turtle_hierarchy_state = HierarchyState("Move Turtle Hierarchy State") preemptive_concurrency_state.add_state(move_turtle_hierarchy_state) preemptive_concurrency_state.add_transition( move_turtle_hierarchy_state.state_id, 0, preemptive_concurrency_state.state_id, 0) spawn_turtle = LibraryState("turtle_libraries", "spawn_turtle", "0.1", "spawn turtle") move_turtle_hierarchy_state.add_state(spawn_turtle) move_turtle_hierarchy_state.set_start_state(spawn_turtle.state_id) wait1 = ExecutionState("Wait1", path=base_path, filename="wait.py") move_turtle_hierarchy_state.add_state(wait1) move_turtle_hierarchy_state.add_transition(spawn_turtle.state_id, 0, wait1.state_id, None) teleport_turtle = LibraryState("turtle_libraries", "teleport_turtle", "0.1", "teleport turtle") move_turtle_hierarchy_state.add_state(teleport_turtle) move_turtle_hierarchy_state.add_transition(wait1.state_id, 0, teleport_turtle.state_id, None) wait2 = ExecutionState("Wait2", path=base_path, filename="wait.py") move_turtle_hierarchy_state.add_state(wait2) move_turtle_hierarchy_state.add_transition(teleport_turtle.state_id, 0, wait2.state_id, None) clear_field = LibraryState("turtle_libraries", "clear_field", "0.1", "clear field") move_turtle_hierarchy_state.add_state(clear_field) move_turtle_hierarchy_state.add_transition(wait2.state_id, 0, clear_field.state_id, None) wait3 = LibraryState(name="Wait3", library_path="generic", library_name="wait") move_turtle_hierarchy_state.add_state(wait3) move_turtle_hierarchy_state.add_transition(clear_field.state_id, 0, wait3.state_id, None) set_velocity1 = LibraryState("turtle_libraries", "set_velocity", "0.1", "set velocity1") move_turtle_hierarchy_state.add_state(set_velocity1) move_turtle_hierarchy_state.add_transition(wait3.state_id, 0, set_velocity1.state_id, None) wait4 = ExecutionState("Wait4", path=base_path, filename="wait.py") move_turtle_hierarchy_state.add_state(wait4) move_turtle_hierarchy_state.add_transition(set_velocity1.state_id, 0, wait4.state_id, None) move_to_position = LibraryState("turtle_libraries", "move_to_position", "0.1", "move to position") move_turtle_hierarchy_state.add_state(move_to_position) move_turtle_hierarchy_state.add_transition(wait4.state_id, 0, move_to_position.state_id, None) move_turtle_hierarchy_state.add_transition(move_to_position.state_id, 1, move_to_position.state_id, None) kill_turtle = LibraryState("turtle_libraries", "kill_turtle", "0.1", "kill turtle") move_turtle_hierarchy_state.add_state(kill_turtle) move_turtle_hierarchy_state.add_transition(move_to_position.state_id, 0, kill_turtle.state_id, None) move_turtle_hierarchy_state.add_transition( kill_turtle.state_id, 0, move_turtle_hierarchy_state.state_id, 0) return basic_turtle_demo_state