def __init__(self, name=None, state_id=None, input_data_ports=None, output_data_ports=None, income=None, outcomes=None, path=None, filename=None, check_path=True, safe_init=True): State.__init__(self, name, state_id, input_data_ports, output_data_ports, income, outcomes, safe_init=safe_init) self._script = None self.script = Script(path, filename, parent=self) self.logger = log.get_logger(self.name) # here all persistent variables that should be available for the next state run should be stored self.persistent_variables = {}
def __init__(self, library_path=None, library_name=None, version=None, # library state specific attributes # the following are the container state specific attributes name=None, state_id=None, income=None, outcomes=None, input_data_port_runtime_values=None, use_runtime_value_input_data_ports=None, output_data_port_runtime_values=None, use_runtime_value_output_data_ports=None, allow_user_interaction=True, safe_init=True, skip_runtime_data_initialization=False): # this variable is set to true if the state initialization is finished! after initialization no change to the # library state is allowed any more self.initialized = False State.__init__(self, name, state_id, None, None, income, outcomes, safe_init=safe_init) self.library_path = library_path self.library_name = library_name self.version = version if global_config.get_config_value("RAISE_ERROR_ON_MISSING_LIBRARY_STATES", False): allow_user_interaction = False lib_os_path, new_library_path, new_library_name = \ library_manager.get_os_path_to_library(library_path, library_name, allow_user_interaction) self.lib_os_path = lib_os_path if library_path != new_library_path or library_name != new_library_name: self.library_name = new_library_name self.library_path = new_library_path # TODO this should trigger the marked_dirty of the state machine to become true logger.info("Changing information about location of library") logger.info("Old library name '{0}' was located at {1}".format(library_name, library_path)) logger.info("New library name '{0}' is located at {1}".format(new_library_name, new_library_path)) lib_version, state_copy = library_manager.get_library_state_copy_instance(self.lib_os_path) if not str(lib_version) == version and not str(lib_version) == "None": raise AttributeError("Library does not have the correct version!") self.state_copy = state_copy if safe_init: LibraryState._safe_init(self, name) else: LibraryState._unsafe_init(self, name) if not skip_runtime_data_initialization: # load_library_root_state_timer.stop(key) self._handle_runtime_values(input_data_port_runtime_values, use_runtime_value_input_data_ports, output_data_port_runtime_values, use_runtime_value_output_data_ports) else: self._input_data_port_runtime_values = input_data_port_runtime_values self._use_runtime_value_input_data_ports = use_runtime_value_input_data_ports self._output_data_port_runtime_values = output_data_port_runtime_values self._use_runtime_value_output_data_ports = use_runtime_value_output_data_ports self.initialized = True
def test_output_gaphas2opengl(): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state.add_output_data_port("out", int, 0) state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_gaphas"]["size"] = (100, 100) state_m.get_meta_data_editor(for_gaphas=False) output_m = state_m.output_data_ports[0] output_m.meta["gui"]["editor_gaphas"]["rel_pos"] = (100, 50) rel_pos = output_m.get_meta_data_editor(for_gaphas=False)["inner_rel_pos"] assert rel_pos == (100, -50)
def test_input_opengl2gaphas(): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state.add_input_data_port("in", int, 0) state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_opengl"]["size"] = (100, 100) state_m.get_meta_data_editor(for_gaphas=True) input_m = state_m.input_data_ports[0] input_m.meta["gui"]["editor_opengl"]["inner_rel_pos"] = (20, -30) rel_pos = input_m.get_meta_data_editor(for_gaphas=True)["rel_pos"] assert rel_pos == (0, 30)
def test_income(): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_opengl"]["size"] = (50, 50) meta_data = state_m.get_meta_data_editor(for_gaphas=True) assert meta_data["income"]["rel_pos"] == (0, 25)
def test_state_rel_pos(use_gaphas): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_opengl" if use_gaphas else "editor_gaphas"][ "rel_pos"] = (1, 2) meta_data = state_m.get_meta_data_editor(for_gaphas=use_gaphas) assert meta_data["rel_pos"] == (1, -2)
def test_4_outcomes(): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state.add_outcome("success2") state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_opengl"]["size"] = (90, 90) state_m.get_meta_data_editor(for_gaphas=True) for outcome_m in state_m.outcomes: outcome = outcome_m.outcome outcome_pos = outcome_m.get_meta_data_editor()["rel_pos"] if outcome.outcome_id == -1: assert outcome_pos == (81, 0) elif outcome.outcome_id == -2: assert outcome_pos == (63, 0) elif outcome.outcome_id == 0: assert outcome_pos == (90, 30) else: assert outcome_pos == (90, 60)
def remove_output_data_port(self, data_port_id, force=False, destroy=True): """Overwrites the remove_output_data_port method of the State class. Prevents user from removing a output data port from the library state. For further documentation, look at the State class. :param bool force: True if the removal should be forced :raises exceptions.NotImplementedError: in the removal is not forced """ if force: return State.remove_output_data_port(self, data_port_id, force, destroy) else: raise NotImplementedError("Remove output data port is not implemented for library state {}".format(self))
def remove_outcome(self, outcome_id, force=False, destroy=True): """Overwrites the remove_outcome method of the State class. Prevents user from removing a outcome from the library state. For further documentation, look at the State class. :raises exceptions.NotImplementedError: in any case """ if force: return State.remove_outcome(self, outcome_id, force, destroy) else: raise NotImplementedError("Remove outcome is not implemented for library state {}".format(self))
def test_state_property_deletion(): testing_utils.dummy_gui(None) from rafcon.core.states.state import State from rafcon.gui.models.state import StateModel state = State() state_m = StateModel(state, parent=None) state_m.meta["gui"]["editor_gaphas"]["income"]["rel_pos"] = (0, 50) state_m.meta["gui"]["editor_gaphas"]["name"]["rel_pos"] = (10, 10) state_m.meta["gui"]["editor_gaphas"]["name"]["size"] = (200, 100) meta_data = state_m.get_meta_data_editor(for_gaphas=False) assert "income" not in meta_data assert "income" not in state_m.meta["gui"]["editor_gaphas"] assert "income" not in state_m.meta["gui"]["editor_opengl"] assert "name" not in meta_data assert "name" not in state_m.meta["gui"]["editor_gaphas"] assert "name" not in state_m.meta["gui"]["editor_opengl"]
def __init__( self, library_path=None, library_name=None, version=None, # library state specific attributes # the following are the container state specific attributes name=None, state_id=None, outcomes=None, input_data_port_runtime_values=None, use_runtime_value_input_data_ports=None, output_data_port_runtime_values=None, use_runtime_value_output_data_ports=None, allow_user_interaction=True): # this variable is set to true if the state initialization is finished! after initialization no change to the # library state is allowed any more self.initialized = False State.__init__(self, name, state_id, None, None, outcomes) self.library_path = library_path self.library_name = library_name self.version = version lib_os_path, new_library_path, new_library_name = \ library_manager.get_os_path_to_library(library_path, library_name, allow_user_interaction) self.lib_os_path = lib_os_path if library_path != new_library_path or library_name != new_library_name: self.library_name = new_library_name self.library_path = new_library_path # TODO this should trigger the marked_dirty of the state machine to become true logger.info("Changing information about location of library") logger.info("Old library name '{0}' was located at {1}".format( library_name, library_path)) logger.info("New library name '{0}' is located at {1}".format( new_library_name, new_library_path)) # key = load_library_root_state_timer.start() lib_version, state_copy = library_manager.get_library_state_copy_instance( self.lib_os_path) self.state_copy = state_copy # load_library_root_state_timer.stop(key) self.state_copy.parent = self if not str(lib_version) == version and not str(lib_version) == "None": raise AttributeError("Library does not have the correct version!") if name is None: self.name = self.state_copy.name # copy all ports and outcomes of self.state_copy to let the library state appear like the container state # this will also set the parent of all outcomes and data ports to self self.outcomes = self.state_copy.outcomes self.input_data_ports = self.state_copy.input_data_ports self.output_data_ports = self.state_copy.output_data_ports # handle input runtime values self.input_data_port_runtime_values = input_data_port_runtime_values self.use_runtime_value_input_data_ports = use_runtime_value_input_data_ports for data_port_id, data_port in self.input_data_ports.iteritems(): # Ensure that all input data ports have a runtime value if data_port_id not in self.input_data_port_runtime_values.iterkeys( ): self.input_data_port_runtime_values[ data_port_id] = data_port.default_value self.use_runtime_value_input_data_ports[data_port_id] = True # Ensure that str and unicode is correctly differentiated elif isinstance(self.input_data_port_runtime_values[data_port_id], basestring): try: self.input_data_port_runtime_values[ data_port_id] = type_helpers.convert_string_value_to_type_value( self.input_data_port_runtime_values[data_port_id], data_port.data_type) except AttributeError: # the parameter cannot be converted # this can be the case when the data type of port of the library state changed self.input_data_port_runtime_values[ data_port_id] = data_port.default_value self.use_runtime_value_input_data_ports[ data_port_id] = True self.marked_dirty = True # if there is a key existing in the runtime values but not in the input_data_ports we delete it for key in self.use_runtime_value_input_data_ports.keys(): if key not in self.input_data_ports.keys(): del self.use_runtime_value_input_data_ports[key] del self.input_data_port_runtime_values[key] # state machine cannot be marked dirty directly, as it does not exist yet self.marked_dirty = True # handle output runtime values self.output_data_port_runtime_values = output_data_port_runtime_values self.use_runtime_value_output_data_ports = use_runtime_value_output_data_ports for data_port_id, data_port in self.output_data_ports.iteritems(): # Ensure that all output data ports have a runtime value if data_port_id not in self.output_data_port_runtime_values.iterkeys( ): self.output_data_port_runtime_values[ data_port_id] = data_port.default_value self.use_runtime_value_output_data_ports[data_port_id] = True # Ensure that str and unicode is correctly differentiated elif isinstance(self.output_data_port_runtime_values[data_port_id], basestring): try: self.output_data_port_runtime_values[data_port_id] = \ type_helpers.convert_string_value_to_type_value( self.output_data_port_runtime_values[data_port_id], data_port.data_type) except AttributeError: # the parameter cannot be converted # this can be the case when the data type of port of the library state changed self.output_data_port_runtime_values[ data_port_id] = data_port.default_value self.use_runtime_value_output_data_ports[ data_port_id] = True self.marked_dirty = True # if there is a key existing in the runtime values but not in the output_data_ports we delete it for key in self.use_runtime_value_output_data_ports.keys(): if key not in self.output_data_ports.keys(): del self.use_runtime_value_output_data_ports[key] del self.output_data_port_runtime_values[key] # state machine cannot be marked dirty directly, as it does not exist yet self.marked_dirty = True self.initialized = True