def _handle_runtime_values(self, input_data_port_runtime_values, use_runtime_value_input_data_ports,
output_data_port_runtime_values, use_runtime_value_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.items():
# Ensure that all input data ports have a runtime value
if data_port_id not in self.input_data_port_runtime_values.keys():
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], str):
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 list(self.use_runtime_value_input_data_ports.keys()):
if key not in self.input_data_ports:
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.items():
# Ensure that all output data ports have a runtime value
if data_port_id not in self.output_data_port_runtime_values.keys():
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], str):
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 list(self.use_runtime_value_output_data_ports.keys()):
if key not in self.output_data_ports:
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
def apply_new_global_variable_value(self, path, new_value_as_string):
"""Change global variable value according handed string
Updates the global variable value only if new value string is different to old representation.
:param path: The path identifying the edited global variable tree view row, can be str, int or tuple.
:param str new_value_as_string: New global variable value as string
"""
if self.list_store[path][
self.DATA_TYPE_AS_STRING_STORAGE_ID] == new_value_as_string:
return
gv_name = self.list_store[path][self.NAME_STORAGE_ID]
if not self.global_variable_is_editable(gv_name, 'Change of value'):
return
data_type = self.model.global_variable_manager.get_data_type(gv_name)
old_value = self.model.global_variable_manager.get_representation(
gv_name)
# preserve type especially if type=NoneType
if issubclass(data_type, (type(old_value), type(None))):
old_type = data_type
if issubclass(data_type, type(None)):
old_type = type(old_value)
logger.debug(
"Trying to parse '{}' to type '{}' of old global variable value '{}'"
.format(new_value_as_string, old_type.__name__, old_value))
try:
new_value = type_helpers.convert_string_value_to_type_value(
new_value_as_string, old_type)
except (AttributeError, ValueError) as e:
if issubclass(data_type, type(None)):
new_value = new_value_as_string
logger.warning(
"New value '{}' stored as string, previous value '{}' of global variable '{}' was "
"of type '{}'".format(new_value, old_value, gv_name,
type(old_value).__name__))
else:
logger.warning(
"Restoring old value of global variable '{}': {}".
format(gv_name, e))
return
else:
logger.error(
"Global variable '{}' with inconsistent value data type '{}' and data type '{}'"
.format(gv_name,
[type(old_value).__name__,
type(None).__name__], data_type.__name__))
return
try:
self.model.global_variable_manager.set_variable(
gv_name, new_value, data_type=data_type)
except (RuntimeError, AttributeError, TypeError) as e:
logger.error(
"Error while setting global variable '{0}' to value '{1}' -> Exception: {2}"
.format(gv_name, new_value, e))
def _unsafe_init(self, name, data_type, default_value, parent):
self._name = name
if data_type is not None:
self._data_type = data_type
if isinstance(default_value, string_types):
self._default_value = type_helpers.convert_string_value_to_type_value(
default_value, data_type)
else:
self._default_value = default_value
if parent:
self._parent = ref(parent)
def check_default_value(self, default_value, data_type=None):
"""Check whether the passed default value suits to the passed data type. If no data type is passed, the
data type of the data port is used. If the default value does not fit, an exception is thrown. If the default
value is of type string, it is tried to convert that value to the data type.
:param default_value: The default value to check
:param data_type: The data type to use
:raises exceptions.AttributeError: if check fails
:return: The converted default value
"""
if data_type is None:
data_type = self.data_type
if default_value is not None:
# If the default value is passed as string, we have to convert it to the data type
if isinstance(default_value, string_types):
if len(default_value) > 1 and default_value[0] == '$':
return default_value
if default_value == "None":
return None
default_value = type_helpers.convert_string_value_to_type_value(
default_value, data_type)
if default_value is None:
raise AttributeError(
"Could not convert default value '{0}' to data type '{1}'."
.format(default_value, data_type))
else:
if not isinstance(default_value, self.data_type):
if self._no_type_error_exceptions:
logger.warning(
"Handed default value '{0}' is of type '{1}' but data port data type is {2} {3}."
"".format(default_value, type(default_value),
data_type, self))
else:
raise TypeError(
"Handed default value '{0}' is of type '{1}' but data port data type is {2}"
"{3} of {4}.".format(
default_value, type(default_value), data_type,
self,
self.parent.get_path()
if self.parent is not None else ""))
return default_value
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
