sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1 value |
|---|---|---|
def set_centralized_assembled_values(self, a):
"""Set assembled matrix values on processor 0."""
if self.myid != 0:
return
assert a.size == self.id.nz
self._refs.update(a=a)
self.id.a = self.cast_array(a) | Set assembled matrix values on processor 0. | entailment |
def set_distributed_assembled(self, irn_loc, jcn_loc, a_loc):
"""Set the distributed assembled matrix.
Distributed assembled matrices require setting icntl(18) != 0.
"""
self.set_distributed_assembled_rows_cols(irn_loc, jcn_loc)
self.set_distributed_assembled_values(a_loc) | Set the distributed assembled matrix.
Distributed assembled matrices require setting icntl(18) != 0. | entailment |
def set_distributed_assembled_rows_cols(self, irn_loc, jcn_loc):
"""Set the distributed assembled matrix row & column numbers.
Distributed assembled matrices require setting icntl(18) != 0.
"""
assert irn_loc.size == jcn_loc.size
self._refs.update(irn_loc=irn_loc, jcn_loc=jcn_loc)
self.id.nz_loc = irn_loc.size
self.id.irn_loc = self.cast_array(irn_loc)
self.id.jcn_loc = self.cast_array(jcn_loc) | Set the distributed assembled matrix row & column numbers.
Distributed assembled matrices require setting icntl(18) != 0. | entailment |
def set_distributed_assembled_values(self, a_loc):
"""Set the distributed assembled matrix values.
Distributed assembled matrices require setting icntl(18) != 0.
"""
assert a_loc.size == self._refs['irn_loc'].size
self._refs.update(a_loc=a_loc)
self.id.a_loc = self.cast_array(a_loc) | Set the distributed assembled matrix values.
Distributed assembled matrices require setting icntl(18) != 0. | entailment |
def set_rhs(self, rhs):
"""Set the right hand side. This matrix will be modified in place."""
assert rhs.size == self.id.n
self._refs.update(rhs=rhs)
self.id.rhs = self.cast_array(rhs) | Set the right hand side. This matrix will be modified in place. | entailment |
def set_silent(self):
"""Silence most messages."""
self.set_icntl(1, -1) # output stream for error msgs
self.set_icntl(2, -1) # otuput stream for diagnostic msgs
self.set_icntl(3, -1) # output stream for global info
self.set_icntl(4, 0) | Silence most messages. | entailment |
def destroy(self):
"""Delete the MUMPS context and release all array references."""
if self.id is not None and self._mumps_c is not None:
self.id.job = -2 # JOB_END
self._mumps_c(self.id)
self.id = None
self._refs = None | Delete the MUMPS context and release all array references. | entailment |
def mumps(self):
"""Call MUMPS, checking for errors in the return code.
The desired job should have already been set using `ctx.set_job(...)`.
As a convenience, you may wish to call `ctx.run(job=...)` which sets
the job and calls MUMPS.
"""
self._mumps_c(self.id)
if self.id.infog[0] < 0:
raise RuntimeError("MUMPS error: %d" % self.id.infog[0]) | Call MUMPS, checking for errors in the return code.
The desired job should have already been set using `ctx.set_job(...)`.
As a convenience, you may wish to call `ctx.run(job=...)` which sets
the job and calls MUMPS. | entailment |
def modify_origin(self, from_state, from_key):
"""Set both from_state and from_key at the same time to modify data flow origin
:param str from_state: State id of the origin state
:param int from_key: Data port id of the origin port
:raises exceptions.ValueError: If parameters have wrong types or the new data flow is not valid
"""
if not isinstance(from_state, string_types):
raise ValueError("Invalid data flow origin port: from_state must be a string")
if not isinstance(from_key, int):
raise ValueError("Invalid data flow origin port: from_key must be of type int")
old_from_state = self.from_state
old_from_key = self.from_key
self._from_state = from_state
self._from_key = from_key
valid, message = self._check_validity()
if not valid:
self._from_state = old_from_state
self._from_key = old_from_key
raise ValueError("The data flow origin could not be changed: {0}".format(message)) | Set both from_state and from_key at the same time to modify data flow origin
:param str from_state: State id of the origin state
:param int from_key: Data port id of the origin port
:raises exceptions.ValueError: If parameters have wrong types or the new data flow is not valid | entailment |
def modify_target(self, to_state, to_key):
"""Set both to_state and to_key at the same time to modify data flow target
:param str to_state: State id of the target state
:param int to_key: Data port id of the target port
:raises exceptions.ValueError: If parameters have wrong types or the new data flow is not valid
"""
if not isinstance(to_state, string_types):
raise ValueError("Invalid data flow target port: from_state must be a string")
if not isinstance(to_key, int):
raise ValueError("Invalid data flow target port: from_outcome must be of type int")
old_to_state = self.to_state
old_to_key = self.to_key
self._to_state = to_state
self._to_key = to_key
valid, message = self._check_validity()
if not valid:
self._to_state = old_to_state
self._to_key = old_to_key
raise ValueError("The data flow target could not be changed: {0}".format(message)) | Set both to_state and to_key at the same time to modify data flow target
:param str to_state: State id of the target state
:param int to_key: Data port id of the target port
:raises exceptions.ValueError: If parameters have wrong types or the new data flow is not valid | entailment |
def register_actions(self, shortcut_manager):
"""Register callback methods for triggered actions
:param rafcon.gui.shortcut_manager.ShortcutManager shortcut_manager: Shortcut Manager Object holding mappings
between shortcuts and actions.
"""
shortcut_manager.add_callback_for_action("copy", self._copy)
shortcut_manager.add_callback_for_action("paste", self._paste)
shortcut_manager.add_callback_for_action("cut", self._cut)
shortcut_manager.add_callback_for_action("undo", self._undo)
shortcut_manager.add_callback_for_action("redo", self._redo)
shortcut_manager.add_callback_for_action("apply", self._apply)
shortcut_manager.add_callback_for_action("open_external_editor", self._open_external_editor) | Register callback methods for triggered actions
:param rafcon.gui.shortcut_manager.ShortcutManager shortcut_manager: Shortcut Manager Object holding mappings
between shortcuts and actions. | entailment |
def code_changed(self, source):
""" Apply checks and adjustments of the TextBuffer and TextView after every change in buffer.
The method re-apply the tag (style) for the buffer. It avoids changes while editable-property set to False
which are caused by a bug in the GtkSourceView2. GtkSourceView2 is the default used TextView widget here.
The text buffer is reset after every change to last stored source-text by a respective work around which
suspends any generation of undo items and avoids a recursive call of the method set_enabled by observing
its while_in_set_enabled flag.
:param TextBuffer source:
:return:
"""
# work around to avoid changes at all (e.g. by enter-key) if text view property editable is False
# TODO if SourceView3 is used in future check if this can be skipped
if not self.view.textview.get_editable() and not self.view.while_in_set_enabled:
if hasattr(self.view.get_buffer(), 'begin_not_undoable_action'):
self.view.get_buffer().begin_not_undoable_action()
self.view.set_enabled(False, self.source_text)
if hasattr(self.view.get_buffer(), 'end_not_undoable_action'):
self.view.get_buffer().end_not_undoable_action()
if self.view:
self.view.apply_tag('default') | Apply checks and adjustments of the TextBuffer and TextView after every change in buffer.
The method re-apply the tag (style) for the buffer. It avoids changes while editable-property set to False
which are caused by a bug in the GtkSourceView2. GtkSourceView2 is the default used TextView widget here.
The text buffer is reset after every change to last stored source-text by a respective work around which
suspends any generation of undo items and avoids a recursive call of the method set_enabled by observing
its while_in_set_enabled flag.
:param TextBuffer source:
:return: | entailment |
def apply_clicked(self, button):
"""Triggered when the Apply-Shortcut in the editor is triggered.
"""
if isinstance(self.model.state, LibraryState):
return
self.set_script_text(self.view.get_text()) | Triggered when the Apply-Shortcut in the editor is triggered. | entailment |
def set_text(self, text):
""" The method insert text into the text buffer of the text view and preserves the cursor location.
:param str text: which is insert into the text buffer.
:return:
"""
line_number, line_offset = self.get_cursor_position()
self.get_buffer().set_text(text)
self.set_cursor_position(line_number, line_offset) | The method insert text into the text buffer of the text view and preserves the cursor location.
:param str text: which is insert into the text buffer.
:return: | entailment |
def set_enabled(self, on, text=None):
""" Set the default input or deactivated (disabled) style scheme
The method triggers the signal 'changed' by using set_text. Therefore, the method use the while_in_set_enabled
flag to make activities of the method observable. If a method trigger this method and was triggered by a
changed-signal this flag is supposed to avoid recursive calls.
:param bool on: enable flag.
:param str text: optional text to insert.
:return:
"""
self.while_in_set_enabled = True
# Apply color scheme by set text 'workaround' (with current buffer source)
self.set_text(self.get_text()) if text is None else self.set_text(text)
if on:
self.textview.set_editable(True)
self.apply_tag('default')
else:
self.apply_tag('deactivated')
self.textview.set_editable(on)
self.while_in_set_enabled = False | Set the default input or deactivated (disabled) style scheme
The method triggers the signal 'changed' by using set_text. Therefore, the method use the while_in_set_enabled
flag to make activities of the method observable. If a method trigger this method and was triggered by a
changed-signal this flag is supposed to avoid recursive calls.
:param bool on: enable flag.
:param str text: optional text to insert.
:return: | entailment |
def pre_init():
"""
The pre_init function of the plugin. Here rafcon-classes can be extended/monkey-patched or completely substituted.
A example is given with the rafcon_execution_hooks_plugin.
:return:
"""
logger.info("Run pre-initiation hook of {} plugin.".format(__file__.split(os.path.sep)[-2]))
# Example: Monkey-Path rafcon.core.script.Script class to print additional log-message while execution
from rafcon.core.script import Script
old_execute_method = Script.execute
def new_execute_method(self, state, inputs=None, outputs=None, backward_execution=False):
logger.debug("patched version of Script class is used.")
result = old_execute_method(self, state, inputs, outputs, backward_execution)
logger.debug("patched version of Script execute-method is finished with result: {}.".format(result))
return result
Script.execute = new_execute_method | The pre_init function of the plugin. Here rafcon-classes can be extended/monkey-patched or completely substituted.
A example is given with the rafcon_execution_hooks_plugin.
:return: | entailment |
def post_init(setup_config):
"""
The post_init function of the plugin. Here observer can be registered to the observables and other pre-init
functionality of the plugin should be triggered. A simple example is given with the rafcon_execution_hooks_plugin.
A complex example is given with the rafcon_monitoring_plugin.
:param setup_config:
:return:
"""
logger.info("Run post-initiation hook of {} plugin.".format(__file__.split(os.path.sep)[-2]))
from . import core_template_observer
# Example 1: initiate observer some elements of the execution engine
core_template_observer.ExecutionEngineObserver()
# Example 2: initiate observer execution status
core_template_observer.ExecutionStatusObserver()
from . import gtkmvc_template_observer
# Example 3: gtkmvc3 general modification observer
# initiate observer of root_state model-object which already implements a power full recursive notification pattern
gtkmvc_template_observer.RootStateModificationObserver()
# Example 4: gtkmvc3 meta signal observer
gtkmvc_template_observer.MetaSignalModificationObserver() | The post_init function of the plugin. Here observer can be registered to the observables and other pre-init
functionality of the plugin should be triggered. A simple example is given with the rafcon_execution_hooks_plugin.
A complex example is given with the rafcon_monitoring_plugin.
:param setup_config:
:return: | entailment |
def reduce_to_parent_states(models):
"""Remove all models of states that have a state model with parent relation in the list
The function filters the list of models, so that for no model in the list, one of it (grand-)parents is also in
the list. E.g. if the input models consists of a hierarchy state with two of its child states, the resulting list
only contains the hierarchy state.
:param set models: The set of selected models
:return: The reduced set of selected models
:rtype: set
"""
models = set(models) # Ensure that models is a set and that we do not operate on the parameter itself
models_to_remove = set()
# check all models
for model in models:
parent_m = model.parent
# check if any (grand-)parent is already in the selection, if so, remove the child
while parent_m is not None:
if parent_m in models:
models_to_remove.add(model)
break
parent_m = parent_m.parent
for model in models_to_remove:
models.remove(model)
if models_to_remove:
logger.debug("The selection has been reduced, as it may not contain elements whose children are also selected")
return models | Remove all models of states that have a state model with parent relation in the list
The function filters the list of models, so that for no model in the list, one of it (grand-)parents is also in
the list. E.g. if the input models consists of a hierarchy state with two of its child states, the resulting list
only contains the hierarchy state.
:param set models: The set of selected models
:return: The reduced set of selected models
:rtype: set | entailment |
def updates_selection(update_selection):
""" Decorator indicating that the decorated method could change the selection"""
def handle_update(selection, *args, **kwargs):
"""Check for changes in the selection
If the selection is changed by the decorated method, the internal core element lists are updated and a signal is
emitted with the old and new selection as well as the name of the method that caused the change..
"""
old_selection = selection.get_all()
update_selection(selection, *args, **kwargs)
new_selection = selection.get_all()
affected_models = old_selection ^ new_selection
if len(affected_models) != 0: # The selection was updated
deselected_models = old_selection - new_selection
selected_models = new_selection - old_selection
map(selection.relieve_model, deselected_models)
map(selection.observe_model, selected_models)
# Maintain internal lists for fast access
selection.update_core_element_lists()
# Clear focus if no longer in selection
if selection.focus and selection.focus not in new_selection:
del selection.focus
# Send notifications about changes
affected_classes = set(model.core_element.__class__ for model in affected_models)
msg_namedtuple = SelectionChangedSignalMsg(update_selection.__name__, new_selection, old_selection,
affected_classes)
selection.selection_changed_signal.emit(msg_namedtuple)
if selection.parent_signal is not None:
selection.parent_signal.emit(msg_namedtuple)
return handle_update | Decorator indicating that the decorated method could change the selection | entailment |
def extend_selection():
"""Checks is the selection is to be extended
The selection is to be extended, if a special modifier key (typically <Ctrl>) is being pressed.
:return: If to extend the selection
:rtype: True
"""
from rafcon.gui.singleton import main_window_controller
currently_pressed_keys = main_window_controller.currently_pressed_keys if main_window_controller else set()
if any(key in currently_pressed_keys for key in [constants.EXTEND_SELECTION_KEY,
constants.EXTEND_SELECTION_KEY_ALT]):
return True
return False | Checks is the selection is to be extended
The selection is to be extended, if a special modifier key (typically <Ctrl>) is being pressed.
:return: If to extend the selection
:rtype: True | entailment |
def _check_model_types(self, models):
""" Check types of passed models for correctness and in case raise exception
:rtype: set
:returns: set of models that are valid for the class"""
if not hasattr(models, "__iter__"):
models = {models}
if not all([isinstance(model, (AbstractStateModel, StateElementModel)) for model in models]):
raise TypeError("The selection supports only models with base class AbstractStateModel or "
"StateElementModel, see handed elements {0}".format(models))
return models if isinstance(models, set) else set(models) | Check types of passed models for correctness and in case raise exception
:rtype: set
:returns: set of models that are valid for the class | entailment |
def add(self, models):
""" Adds the passed model(s) to the selection"""
if models is None:
return
models = self._check_model_types(models)
self._selected.update(models)
self._selected = reduce_to_parent_states(self._selected) | Adds the passed model(s) to the selection | entailment |
def remove(self, models):
""" Removed the passed model(s) from the selection"""
models = self._check_model_types(models)
for model in models:
if model in self._selected:
self._selected.remove(model) | Removed the passed model(s) from the selection | entailment |
def set(self, models):
""" Sets the selection to the passed model(s) """
# Do not add None values to selection
if models is None:
models = set()
models = self._check_model_types(models)
if len(models) > 1:
models = reduce_to_parent_states(models)
self._selected = set(models) | Sets the selection to the passed model(s) | entailment |
def handle_prepared_selection_of_core_class_elements(self, core_class, models):
"""Handles the selection for TreeStore widgets maintaining lists of a specific `core_class` elements
If widgets hold a TreeStore with elements of a specific `core_class`, the local selection of that element
type is handled by that widget. This method is called to integrate the local selection with the overall
selection of the state machine.
If no modifier key (indicating to extend the selection) is pressed, the state machine selection is set to the
passed selection. If the selection is to be extended, the state machine collection will consist of the widget
selection plus all previously selected elements not having the core class `core_class`.
:param State | StateElement core_class: The core class of the elements the widget handles
:param models: The list of models that are currently being selected locally
"""
if extend_selection():
self._selected.difference_update(self.get_selected_elements_of_core_class(core_class))
else:
self._selected.clear()
models = self._check_model_types(models)
if len(models) > 1:
models = reduce_to_parent_states(models)
self._selected.update(models) | Handles the selection for TreeStore widgets maintaining lists of a specific `core_class` elements
If widgets hold a TreeStore with elements of a specific `core_class`, the local selection of that element
type is handled by that widget. This method is called to integrate the local selection with the overall
selection of the state machine.
If no modifier key (indicating to extend the selection) is pressed, the state machine selection is set to the
passed selection. If the selection is to be extended, the state machine collection will consist of the widget
selection plus all previously selected elements not having the core class `core_class`.
:param State | StateElement core_class: The core class of the elements the widget handles
:param models: The list of models that are currently being selected locally | entailment |
def handle_new_selection(self, models):
"""Handles the selection for generic widgets
This is a helper method for generic widgets that want to modify the selection. These widgets can pass a list
of newly selected (or clicked on) models.
The method looks at the previous selection, the passed models and the list of pressed (modifier) keys:
* If no modifier key is pressed, the previous selection is cleared and the new selection is set to the passed
models
* If the extend-selection modifier key is pressed, elements of `models` that are _not_ in the previous
selection are selected, those that are in the previous selection are deselected
:param models: The list of models that are newly selected/clicked on
"""
models = self._check_model_types(models)
if extend_selection():
already_selected_elements = models & self._selected
newly_selected_elements = models - self._selected
self._selected.difference_update(already_selected_elements)
self._selected.update(newly_selected_elements)
else:
self._selected = models
self._selected = reduce_to_parent_states(self._selected) | Handles the selection for generic widgets
This is a helper method for generic widgets that want to modify the selection. These widgets can pass a list
of newly selected (or clicked on) models.
The method looks at the previous selection, the passed models and the list of pressed (modifier) keys:
* If no modifier key is pressed, the previous selection is cleared and the new selection is set to the passed
models
* If the extend-selection modifier key is pressed, elements of `models` that are _not_ in the previous
selection are selected, those that are in the previous selection are deselected
:param models: The list of models that are newly selected/clicked on | entailment |
def focus(self, model):
"""Sets the passed model as focused element
:param ModelMT model: The element to be focused
"""
if model is None:
del self.focus
return
self._check_model_types(model)
self.add(model)
focus_msg = FocusSignalMsg(model, self._focus)
self._focus = model
self._selected.add(model)
self._selected = reduce_to_parent_states(self._selected)
self.focus_signal.emit(focus_msg) | Sets the passed model as focused element
:param ModelMT model: The element to be focused | entailment |
def focus(self):
""" Unsets the focused element """
focus_msg = FocusSignalMsg(None, self._focus)
self._focus = None
self.focus_signal.emit(focus_msg) | Unsets the focused element | entailment |
def update_core_element_lists(self):
""" Maintains inner lists of selected elements with a specific core element class """
def get_selected_elements_of_core_class(core_class):
return set(element for element in self._selected if isinstance(element.core_element, core_class))
self._states = get_selected_elements_of_core_class(State)
self._transitions = get_selected_elements_of_core_class(Transition)
self._data_flows = get_selected_elements_of_core_class(DataFlow)
self._input_data_ports = get_selected_elements_of_core_class(InputDataPort)
self._output_data_ports = get_selected_elements_of_core_class(OutputDataPort)
self._scoped_variables = get_selected_elements_of_core_class(ScopedVariable)
self._outcomes = get_selected_elements_of_core_class(Outcome) | Maintains inner lists of selected elements with a specific core element class | entailment |
def get_selected_elements_of_core_class(self, core_element_type):
"""Returns all selected elements having the specified `core_element_type` as state element class
:return: Subset of the selection, only containing elements having `core_element_type` as state element class
:rtype: set
"""
if core_element_type is Outcome:
return self.outcomes
elif core_element_type is InputDataPort:
return self.input_data_ports
elif core_element_type is OutputDataPort:
return self.output_data_ports
elif core_element_type is ScopedVariable:
return self.scoped_variables
elif core_element_type is Transition:
return self.transitions
elif core_element_type is DataFlow:
return self.data_flows
elif core_element_type is State:
return self.states
raise RuntimeError("Invalid core element type: " + core_element_type) | Returns all selected elements having the specified `core_element_type` as state element class
:return: Subset of the selection, only containing elements having `core_element_type` as state element class
:rtype: set | entailment |
def is_selected(self, model):
"""Checks whether the given model is selected
:param model:
:return: True if the model is within the selection, False else
:rtype: bool
"""
if model is None:
return len(self._selected) == 0
return model in self._selected | Checks whether the given model is selected
:param model:
:return: True if the model is within the selection, False else
:rtype: bool | entailment |
def execute_command_with_path_in_process(command, path, shell=False, cwd=None, logger=None):
"""Executes a specific command in a separate process with a path as argument.
:param command: the command to be executed
:param path: the path as first argument to the shell command
:param bool shell: Whether to use a shell
:param str cwd: The working directory of the command
:param logger: optional logger instance which can be handed from other module
:return: None
"""
if logger is None:
logger = _logger
logger.debug("Opening path with command: {0} {1}".format(command, path))
# This splits the command in a matter so that the command gets called in a separate shell and thus
# does not lock the window.
args = shlex.split('{0} "{1}"'.format(command, path))
try:
subprocess.Popen(args, shell=shell, cwd=cwd)
return True
except OSError as e:
logger.error('The operating system raised an error: {}'.format(e))
return False | Executes a specific command in a separate process with a path as argument.
:param command: the command to be executed
:param path: the path as first argument to the shell command
:param bool shell: Whether to use a shell
:param str cwd: The working directory of the command
:param logger: optional logger instance which can be handed from other module
:return: None | entailment |
def execute_command_in_process(command, shell=False, cwd=None, logger=None):
""" Executes a specific command in a separate process
:param command: the command to be executed
:param bool shell: Whether to use a shell
:param str cwd: The working directory of the command
:param logger: optional logger instance which can be handed from other module
:return: None
"""
if logger is None:
logger = _logger
logger.debug("Run shell command: {0}".format(command))
try:
subprocess.Popen(command, shell=shell, cwd=cwd)
return True
except OSError as e:
logger.error('The operating system raised an error: {}'.format(e))
return False | Executes a specific command in a separate process
:param command: the command to be executed
:param bool shell: Whether to use a shell
:param str cwd: The working directory of the command
:param logger: optional logger instance which can be handed from other module
:return: None | entailment |
def _load_child_state_models(self, load_meta_data):
"""Adds models for each child state of the state
:param bool load_meta_data: Whether to load the meta data of the child state
"""
self.states = {}
# Create model for each child class
child_states = self.state.states
for child_state in child_states.values():
# Create hierarchy
model_class = get_state_model_class_for_state(child_state)
if model_class is not None:
self._add_model(self.states, child_state, model_class, child_state.state_id, load_meta_data)
else:
logger.error("Unknown state type '{type:s}'. Cannot create model.".format(type=type(child_state))) | Adds models for each child state of the state
:param bool load_meta_data: Whether to load the meta data of the child state | entailment |
def _load_scoped_variable_models(self):
""" Adds models for each scoped variable of the state """
self.scoped_variables = []
for scoped_variable in self.state.scoped_variables.values():
self._add_model(self.scoped_variables, scoped_variable, ScopedVariableModel) | Adds models for each scoped variable of the state | entailment |
def _load_data_flow_models(self):
""" Adds models for each data flow of the state """
self.data_flows = []
for data_flow in self.state.data_flows.values():
self._add_model(self.data_flows, data_flow, DataFlowModel) | Adds models for each data flow of the state | entailment |
def _load_transition_models(self):
""" Adds models for each transition of the state """
self.transitions = []
for transition in self.state.transitions.values():
self._add_model(self.transitions, transition, TransitionModel) | Adds models for each transition of the state | entailment |
def prepare_destruction(self, recursive=True):
"""Prepares the model for destruction
Recursively un-registers all observers and removes references to child models. Extends the destroy method of
the base class by child elements of a container state.
"""
# logger.verbose("Prepare destruction container state ...")
if recursive:
for scoped_variable in self.scoped_variables:
scoped_variable.prepare_destruction()
for connection in self.transitions[:] + self.data_flows[:]:
connection.prepare_destruction()
for state in self.states.values():
state.prepare_destruction(recursive)
del self.scoped_variables[:]
del self.transitions[:]
del self.data_flows[:]
self.states.clear()
self.scoped_variables = None
self.transitions = None
self.data_flows = None
self.states = None
super(ContainerStateModel, self).prepare_destruction(recursive) | Prepares the model for destruction
Recursively un-registers all observers and removes references to child models. Extends the destroy method of
the base class by child elements of a container state. | entailment |
def model_changed(self, model, prop_name, info):
"""This method notifies the model lists and the parent state about changes
The method is called each time, the model is changed. This happens, when the state itself changes or one of
its children (states, transitions, data flows) changes. Changes of the children cannot be observed directly,
therefore children notify their parent about their changes by calling this method.
This method then checks, what has been changed by looking at the model that is passed to it. In the following it
notifies the list in which the change happened about the change.
E.g. one child state changes its name. The model of that state observes itself and notifies the parent (
i.e. this state model) about the change by calling this method with the information about the change. This
method recognizes that the model is of type StateModel and therefore triggers a notify on the list of state
models.
"_notify_method_before" is used as trigger method when the changing function is entered and
"_notify_method_after" is used when the changing function returns. This changing function in the example
would be the setter of the property name.
:param model: The model that was changed
:param prop_name: The property that was changed
:param info: Information about the change (e.g. the name of the changing function)
"""
# if info.method_name == 'change_state_type': # Handled in method 'change_state_type'
# return
# If this model has been changed (and not one of its child states), then we have to update all child models
# This must be done before notifying anybody else, because other may relay on the updated models
if self.state == info['instance']:
if 'after' in info:
self.update_child_models(model, prop_name, info)
# if there is and exception set is_about_to_be_destroyed_recursively flag to False again
if info.method_name in ["remove_state"] and isinstance(info.result, Exception):
state_id = info.kwargs['state_id'] if 'state_id' in info.kwargs else info.args[1]
self.states[state_id].is_about_to_be_destroyed_recursively = False
else:
# while before notification mark all states which get destroyed recursively
if info.method_name in ["remove_state"] and \
info.kwargs.get('destroy', True) and info.kwargs.get('recursive', True):
state_id = info.kwargs['state_id'] if 'state_id' in info.kwargs else info.args[1]
self.states[state_id].is_about_to_be_destroyed_recursively = True
changed_list = None
cause = None
# If the change happened in a child state, notify the list of all child states
if (isinstance(model, AbstractStateModel) and model is not self) or ( # The state was changed directly
not isinstance(model, AbstractStateModel) and model.parent is not self): # One of the member models was changed
changed_list = self.states
cause = 'state_change'
# If the change happened in one of the transitions, notify the list of all transitions
elif isinstance(model, TransitionModel) and model.parent is self:
changed_list = self.transitions
cause = 'transition_change'
# If the change happened in one of the data flows, notify the list of all data flows
elif isinstance(model, DataFlowModel) and model.parent is self:
changed_list = self.data_flows
cause = 'data_flow_change'
# If the change happened in one of the scoped variables, notify the list of all scoped variables
elif isinstance(model, ScopedVariableModel) and model.parent is self:
changed_list = self.scoped_variables
cause = 'scoped_variable_change'
if not (cause is None or changed_list is None):
if 'before' in info:
changed_list._notify_method_before(self.state, cause, (self.state,), info)
elif 'after' in info:
changed_list._notify_method_after(self.state, cause, None, (self.state,), info)
# Finally call the method of the base class, to forward changes in ports and outcomes
super(ContainerStateModel, self).model_changed(model, prop_name, info) | This method notifies the model lists and the parent state about changes
The method is called each time, the model is changed. This happens, when the state itself changes or one of
its children (states, transitions, data flows) changes. Changes of the children cannot be observed directly,
therefore children notify their parent about their changes by calling this method.
This method then checks, what has been changed by looking at the model that is passed to it. In the following it
notifies the list in which the change happened about the change.
E.g. one child state changes its name. The model of that state observes itself and notifies the parent (
i.e. this state model) about the change by calling this method with the information about the change. This
method recognizes that the model is of type StateModel and therefore triggers a notify on the list of state
models.
"_notify_method_before" is used as trigger method when the changing function is entered and
"_notify_method_after" is used when the changing function returns. This changing function in the example
would be the setter of the property name.
:param model: The model that was changed
:param prop_name: The property that was changed
:param info: Information about the change (e.g. the name of the changing function) | entailment |
def update_child_models(self, _, name, info):
""" This method is always triggered when the state model changes
It keeps the following models/model-lists consistent:
transition models
data-flow models
state models
scoped variable models
"""
# Update is_start flag in child states if the start state has changed (eventually)
if info.method_name in ['start_state_id', 'add_transition', 'remove_transition']:
self.update_child_is_start()
if info.method_name in ["add_transition", "remove_transition", "transitions"]:
(model_list, data_list, model_name, model_class, model_key) = self._get_model_info("transition")
elif info.method_name in ["add_data_flow", "remove_data_flow", "data_flows"]:
(model_list, data_list, model_name, model_class, model_key) = self._get_model_info("data_flow")
elif info.method_name in ["add_state", "remove_state", "states"]:
(model_list, data_list, model_name, model_class, model_key) = self._get_model_info("state", info)
elif info.method_name in ["add_scoped_variable", "remove_scoped_variable", "scoped_variables"]:
(model_list, data_list, model_name, model_class, model_key) = self._get_model_info("scoped_variable")
else:
return
if isinstance(info.result, Exception):
# Do nothing if the observed function raised an exception
pass
elif "add" in info.method_name:
self.add_missing_model(model_list, data_list, model_name, model_class, model_key)
elif "remove" in info.method_name:
destroy = info.kwargs.get('destroy', True)
recursive = info.kwargs.get('recursive', True)
self.remove_specific_model(model_list, info.result, model_key, recursive, destroy)
elif info.method_name in ["transitions", "data_flows", "states", "scoped_variables"]:
self.re_initiate_model_list(model_list, data_list, model_name, model_class, model_key) | This method is always triggered when the state model changes
It keeps the following models/model-lists consistent:
transition models
data-flow models
state models
scoped variable models | entailment |
def get_scoped_variable_m(self, data_port_id):
"""Returns the scoped variable model for the given data port id
:param data_port_id: The data port id to search for
:return: The model of the scoped variable with the given id
"""
for scoped_variable_m in self.scoped_variables:
if scoped_variable_m.scoped_variable.data_port_id == data_port_id:
return scoped_variable_m
return None | Returns the scoped variable model for the given data port id
:param data_port_id: The data port id to search for
:return: The model of the scoped variable with the given id | entailment |
def get_data_port_m(self, data_port_id):
"""Searches and returns the model of a data port of a given state
The method searches a port with the given id in the data ports of the given state model. If the state model
is a container state, not only the input and output data ports are looked at, but also the scoped variables.
:param data_port_id: The data port id to be searched
:return: The model of the data port or None if it is not found
"""
for scoped_var_m in self.scoped_variables:
if scoped_var_m.scoped_variable.data_port_id == data_port_id:
return scoped_var_m
return StateModel.get_data_port_m(self, data_port_id) | Searches and returns the model of a data port of a given state
The method searches a port with the given id in the data ports of the given state model. If the state model
is a container state, not only the input and output data ports are looked at, but also the scoped variables.
:param data_port_id: The data port id to be searched
:return: The model of the data port or None if it is not found | entailment |
def get_transition_m(self, transition_id):
"""Searches and return the transition model with the given in the given container state model
:param transition_id: The transition id to be searched
:return: The model of the transition or None if it is not found
"""
for transition_m in self.transitions:
if transition_m.transition.transition_id == transition_id:
return transition_m
return None | Searches and return the transition model with the given in the given container state model
:param transition_id: The transition id to be searched
:return: The model of the transition or None if it is not found | entailment |
def get_data_flow_m(self, data_flow_id):
"""Searches and return the data flow model with the given in the given container state model
:param data_flow_id: The data flow id to be searched
:return: The model of the data flow or None if it is not found
"""
for data_flow_m in self.data_flows:
if data_flow_m.data_flow.data_flow_id == data_flow_id:
return data_flow_m
return None | Searches and return the data flow model with the given in the given container state model
:param data_flow_id: The data flow id to be searched
:return: The model of the data flow or None if it is not found | entailment |
def store_meta_data(self, copy_path=None):
"""Store meta data of container states to the filesystem
Recursively stores meta data of child states. For further insides read the description of also called respective
super class method.
:param str copy_path: Optional copy path if meta data is not stored to the file system path of state machine
"""
super(ContainerStateModel, self).store_meta_data(copy_path)
for state_key, state in self.states.items():
state.store_meta_data(copy_path) | Store meta data of container states to the filesystem
Recursively stores meta data of child states. For further insides read the description of also called respective
super class method.
:param str copy_path: Optional copy path if meta data is not stored to the file system path of state machine | entailment |
def copy_meta_data_from_state_m(self, source_state_m):
"""Dismiss current meta data and copy meta data from given state model
In addition to the state model method, also the meta data of container states is copied. Then, the meta data
of child states are recursively copied.
:param source_state_m: State model to load the meta data from
"""
for scoped_variable_m in self.scoped_variables:
source_scoped_variable_m = source_state_m.get_scoped_variable_m(
scoped_variable_m.scoped_variable.data_port_id)
scoped_variable_m.meta = deepcopy(source_scoped_variable_m.meta)
for transition_m in self.transitions:
source_transition_m = source_state_m.get_transition_m(transition_m.transition.transition_id)
transition_m.meta = deepcopy(source_transition_m.meta)
for data_flow_m in self.data_flows:
source_data_flow_m = source_state_m.get_data_flow_m(data_flow_m.data_flow.data_flow_id)
data_flow_m.meta = deepcopy(source_data_flow_m.meta)
for state_key, state in self.states.items():
state.copy_meta_data_from_state_m(source_state_m.states[state_key])
super(ContainerStateModel, self).copy_meta_data_from_state_m(source_state_m) | Dismiss current meta data and copy meta data from given state model
In addition to the state model method, also the meta data of container states is copied. Then, the meta data
of child states are recursively copied.
:param source_state_m: State model to load the meta data from | entailment |
def _generate_element_meta_data(self, meta_data):
"""Generate meta data for state elements and add it to the given dictionary
This method retrieves the meta data of the container state elements (data flows, transitions) and adds it
to the given meta data dictionary.
:param meta_data: Dictionary of meta data
"""
super(ContainerStateModel, self)._generate_element_meta_data(meta_data)
for transition_m in self.transitions:
self._copy_element_meta_data_to_meta_file_data(meta_data, transition_m, "transition",
transition_m.transition.transition_id)
for data_flow_m in self.data_flows:
self._copy_element_meta_data_to_meta_file_data(meta_data, data_flow_m, "data_flow",
data_flow_m.data_flow.data_flow_id)
for scoped_variable_m in self.scoped_variables:
self._copy_element_meta_data_to_meta_file_data(meta_data, scoped_variable_m, "scoped_variable",
scoped_variable_m.scoped_variable.data_port_id) | Generate meta data for state elements and add it to the given dictionary
This method retrieves the meta data of the container state elements (data flows, transitions) and adds it
to the given meta data dictionary.
:param meta_data: Dictionary of meta data | entailment |
def open_folder(query, default_path=None):
"""Shows a user dialog for folder selection
A dialog is opened with the prompt `query`. The current path is set to the last path that was opened/created. The
roots of all libraries is added to the list of shortcut folders.
:param str query: Prompt asking the user for a specific folder
:param str default_path: Path to use if user does not specify one
:return: Path selected by the user or `default_path` if no path was specified or None if none of the paths is valid
:rtype: str
"""
from gi.repository import Gtk
from os.path import expanduser, pathsep, dirname, isdir
from rafcon.gui.singleton import main_window_controller
from rafcon.gui.runtime_config import global_runtime_config
last_path = global_runtime_config.get_config_value('LAST_PATH_OPEN_SAVE', "")
selected_filename = None
if last_path and isdir(last_path):
selected_filename = last_path.split(pathsep)[-1]
last_path = dirname(last_path)
else:
last_path = expanduser('~')
dialog = Gtk.FileChooserDialog(query,
None,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OPEN, Gtk.ResponseType.OK))
# Allows confirming with Enter and double-click
dialog.set_default_response(Gtk.ResponseType.OK)
if main_window_controller:
dialog.set_transient_for(main_window_controller.view.get_top_widget())
dialog.set_current_folder(last_path)
if selected_filename is not None:
dialog.select_filename(selected_filename)
dialog.set_show_hidden(False)
# Add library roots to list of shortcut folders
add_library_root_path_to_shortcut_folders_of_dialog(dialog)
response = dialog.run()
if response != Gtk.ResponseType.OK:
dialog.destroy()
if default_path and os.path.isdir(default_path):
return default_path
return None
path = dialog.get_filename()
dialog.destroy()
if os.path.isdir(path):
global_runtime_config.set_config_value('LAST_PATH_OPEN_SAVE', path)
return path
return None | Shows a user dialog for folder selection
A dialog is opened with the prompt `query`. The current path is set to the last path that was opened/created. The
roots of all libraries is added to the list of shortcut folders.
:param str query: Prompt asking the user for a specific folder
:param str default_path: Path to use if user does not specify one
:return: Path selected by the user or `default_path` if no path was specified or None if none of the paths is valid
:rtype: str | entailment |
def create_folder(query, default_name=None, default_path=None):
"""Shows a user dialog for folder creation
A dialog is opened with the prompt `query`. The current path is set to the last path that was opened/created. The
roots of all libraries is added to the list of shortcut folders.
:param str query: Prompt asking the user for a specific folder
:param str default_name: Default name of the folder to be created
:param str default_path: Path in which the folder is created if the user doesn't specify a path
:return: Path created by the user or `default_path`\`default_name` if no path was specified or None if none of the
paths is valid
:rtype: str
"""
from gi.repository import Gtk
from os.path import expanduser, dirname, join, exists, isdir
from rafcon.core.storage.storage import STATEMACHINE_FILE
from rafcon.gui.singleton import main_window_controller
from rafcon.gui.runtime_config import global_runtime_config
last_path = global_runtime_config.get_config_value('LAST_PATH_OPEN_SAVE', "")
if last_path and isdir(last_path) and not exists(join(last_path, STATEMACHINE_FILE)):
pass
elif last_path:
last_path = dirname(last_path)
else:
last_path = expanduser('~')
dialog = Gtk.FileChooserDialog(query,
None,
Gtk.FileChooserAction.CREATE_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
# Allows confirming with Enter and double-click
dialog.set_default_response(Gtk.ResponseType.OK)
if main_window_controller:
dialog.set_transient_for(main_window_controller.view.get_top_widget())
dialog.set_current_folder(last_path)
if default_name:
dialog.set_current_name(default_name)
dialog.set_show_hidden(False)
# Add library roots to list of shortcut folders
add_library_root_path_to_shortcut_folders_of_dialog(dialog)
response = dialog.run()
if response != Gtk.ResponseType.OK:
dialog.destroy()
if default_path and default_name:
default = os.path.join(default_path, default_name)
if os.path.isdir(default):
return default
return None
path = dialog.get_filename()
dialog.destroy()
if os.path.isdir(path):
global_runtime_config.set_config_value('LAST_PATH_OPEN_SAVE', path)
return path
return None | Shows a user dialog for folder creation
A dialog is opened with the prompt `query`. The current path is set to the last path that was opened/created. The
roots of all libraries is added to the list of shortcut folders.
:param str query: Prompt asking the user for a specific folder
:param str default_name: Default name of the folder to be created
:param str default_path: Path in which the folder is created if the user doesn't specify a path
:return: Path created by the user or `default_path`\`default_name` if no path was specified or None if none of the
paths is valid
:rtype: str | entailment |
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) | Create a new state-machine when the user clicks on the '+' next to the tabs | entailment |
def register_view(self, view):
"""Called when the View was registered"""
super(StateMachinesEditorController, self).register_view(view)
self.view['notebook'].connect('switch-page', self.on_switch_page)
# Add all already open state machines
for state_machine in self.model.state_machines.values():
self.add_graphical_state_machine_editor(state_machine) | Called when the View was registered | entailment |
def register_actions(self, shortcut_manager):
"""Register callback methods fot triggered actions.
:param rafcon.gui.shortcut_manager.ShortcutManager shortcut_manager: Shortcut Manager Object holding mappings
between shortcuts and actions.
"""
shortcut_manager.add_callback_for_action('close', self.on_close_shortcut)
# Call register_action of parent in order to register actions for child controllers
super(StateMachinesEditorController, self).register_actions(shortcut_manager) | Register callback methods fot triggered actions.
:param rafcon.gui.shortcut_manager.ShortcutManager shortcut_manager: Shortcut Manager Object holding mappings
between shortcuts and actions. | entailment |
def close_state_machine(self, widget, page_number, event=None):
"""Triggered when the close button in the tab is clicked
"""
page = widget.get_nth_page(page_number)
for tab_info in self.tabs.values():
if tab_info['page'] is page:
state_machine_m = tab_info['state_machine_m']
self.on_close_clicked(event, state_machine_m, None, force=False)
return | Triggered when the close button in the tab is clicked | entailment |
def on_close_shortcut(self, *args):
"""Close selected state machine (triggered by shortcut)"""
state_machine_m = self.model.get_selected_state_machine_model()
if state_machine_m is None:
return
self.on_close_clicked(None, state_machine_m, None, force=False) | Close selected state machine (triggered by shortcut) | entailment |
def add_graphical_state_machine_editor(self, state_machine_m):
"""Add to for new state machine
If a new state machine was added, a new tab is created with a graphical editor for this state machine.
:param StateMachineModel state_machine_m: The new state machine model
"""
assert isinstance(state_machine_m, StateMachineModel)
sm_id = state_machine_m.state_machine.state_machine_id
logger.debug("Create new graphical editor for state machine with id %s" % str(sm_id))
graphical_editor_view = GraphicalEditorGaphasView(state_machine_m)
graphical_editor_ctrl = GraphicalEditorGaphasController(state_machine_m, graphical_editor_view)
self.add_controller(sm_id, graphical_editor_ctrl)
tab, tab_label = create_tab_header('', self.on_close_clicked, self.on_mouse_right_click,
state_machine_m, 'refused')
set_tab_label_texts(tab_label, state_machine_m, state_machine_m.state_machine.marked_dirty)
page = graphical_editor_view['main_frame']
self.view.notebook.append_page(page, tab)
self.view.notebook.set_tab_reorderable(page, True)
page.show_all()
self.tabs[sm_id] = {'page': page,
'state_machine_m': state_machine_m,
'file_system_path': state_machine_m.state_machine.file_system_path,
'marked_dirty': state_machine_m.state_machine.marked_dirty,
'root_state_name': state_machine_m.state_machine.root_state.name}
self.observe_model(state_machine_m)
graphical_editor_view.show()
self.view.notebook.show()
self.last_focused_state_machine_ids.append(sm_id) | Add to for new state machine
If a new state machine was added, a new tab is created with a graphical editor for this state machine.
:param StateMachineModel state_machine_m: The new state machine model | entailment |
def notification_selected_sm_changed(self, model, prop_name, info):
"""If a new state machine is selected, make sure the tab is open"""
selected_state_machine_id = self.model.selected_state_machine_id
if selected_state_machine_id is None:
return
page_id = self.get_page_num(selected_state_machine_id)
# to retrieve the current tab colors
number_of_pages = self.view["notebook"].get_n_pages()
old_label_colors = list(range(number_of_pages))
for p in range(number_of_pages):
page = self.view["notebook"].get_nth_page(p)
label = self.view["notebook"].get_tab_label(page).get_child().get_children()[0]
# old_label_colors[p] = label.get_style().fg[Gtk.StateType.NORMAL]
old_label_colors[p] = label.get_style_context().get_color(Gtk.StateType.NORMAL)
if not self.view.notebook.get_current_page() == page_id:
self.view.notebook.set_current_page(page_id)
# set the old colors
for p in range(number_of_pages):
page = self.view["notebook"].get_nth_page(p)
label = self.view["notebook"].get_tab_label(page).get_child().get_children()[0]
# Gtk TODO
style = label.get_style_context() | If a new state machine is selected, make sure the tab is open | entailment |
def update_state_machine_tab_label(self, state_machine_m):
""" Updates tab label if needed because system path, root state name or marked_dirty flag changed
:param StateMachineModel state_machine_m: State machine model that has changed
:return:
"""
sm_id = state_machine_m.state_machine.state_machine_id
if sm_id in self.tabs:
sm = state_machine_m.state_machine
# create new tab label if tab label properties are not up to date
if not self.tabs[sm_id]['marked_dirty'] == sm.marked_dirty or \
not self.tabs[sm_id]['file_system_path'] == sm.file_system_path or \
not self.tabs[sm_id]['root_state_name'] == sm.root_state.name:
label = self.view["notebook"].get_tab_label(self.tabs[sm_id]["page"]).get_child().get_children()[0]
set_tab_label_texts(label, state_machine_m, unsaved_changes=sm.marked_dirty)
self.tabs[sm_id]['file_system_path'] = sm.file_system_path
self.tabs[sm_id]['marked_dirty'] = sm.marked_dirty
self.tabs[sm_id]['root_state_name'] = sm.root_state.name
else:
logger.warning("State machine '{0}' tab label can not be updated there is no tab.".format(sm_id)) | Updates tab label if needed because system path, root state name or marked_dirty flag changed
:param StateMachineModel state_machine_m: State machine model that has changed
:return: | entailment |
def on_close_clicked(self, event, state_machine_m, result, force=False):
"""Triggered when the close button of a state machine tab is clicked
Closes state machine if it is saved. Otherwise gives the user the option to 'Close without Saving' or to 'Cancel
the Close Operation'
:param state_machine_m: The selected state machine model.
"""
from rafcon.core.singleton import state_machine_execution_engine, state_machine_manager
force = True if event is not None and hasattr(event, 'state') \
and event.get_state() & Gdk.ModifierType.SHIFT_MASK \
and event.get_state() & Gdk.ModifierType.CONTROL_MASK else force
def remove_state_machine_m():
state_machine_id = state_machine_m.state_machine.state_machine_id
if state_machine_id in self.model.state_machine_manager.state_machines:
self.model.state_machine_manager.remove_state_machine(state_machine_id)
def push_sm_running_dialog():
message_string = "The state machine is still running. Are you sure you want to close?"
dialog = RAFCONButtonDialog(message_string, ["Stop and close", "Cancel"],
message_type=Gtk.MessageType.QUESTION, parent=self.get_root_window())
response_id = dialog.run()
dialog.destroy()
if response_id == 1:
logger.debug("State machine execution is being stopped")
state_machine_execution_engine.stop()
state_machine_execution_engine.join()
# wait for gui is needed; otherwise the signals related to the execution engine cannot
# be processed properly by the state machine under destruction
rafcon.gui.utils.wait_for_gui()
remove_state_machine_m()
return True
elif response_id == 2:
logger.debug("State machine execution will keep running")
return False
def push_sm_dirty_dialog():
sm_id = state_machine_m.state_machine.state_machine_id
root_state_name = state_machine_m.root_state.state.name
message_string = "There are unsaved changes in the state machine '{0}' with id {1}. Do you want to close " \
"the state machine anyway?".format(root_state_name, sm_id)
dialog = RAFCONButtonDialog(message_string, ["Close without saving", "Cancel"],
message_type=Gtk.MessageType.QUESTION, parent=self.get_root_window())
response_id = dialog.run()
dialog.destroy()
if response_id == 1: # Close without saving pressed
remove_state_machine_m()
return True
else:
logger.debug("Closing of state machine canceled")
return False
# sm running
if not state_machine_execution_engine.finished_or_stopped() and \
state_machine_manager.active_state_machine_id == state_machine_m.state_machine.state_machine_id:
return push_sm_running_dialog()
# close is forced -> sm not saved
elif force:
remove_state_machine_m()
return True
# sm dirty -> save sm request dialog
elif state_machine_m.state_machine.marked_dirty:
return push_sm_dirty_dialog()
else:
remove_state_machine_m()
return True | Triggered when the close button of a state machine tab is clicked
Closes state machine if it is saved. Otherwise gives the user the option to 'Close without Saving' or to 'Cancel
the Close Operation'
:param state_machine_m: The selected state machine model. | entailment |
def close_all_pages(self):
"""Closes all tabs of the state machines editor."""
state_machine_m_list = [tab['state_machine_m'] for tab in self.tabs.values()]
for state_machine_m in state_machine_m_list:
self.on_close_clicked(None, state_machine_m, None, force=True) | Closes all tabs of the state machines editor. | entailment |
def refresh_state_machines(self, state_machine_ids):
""" Refresh list af state machine tabs
:param list state_machine_ids: List of state machine ids to be refreshed
:return:
"""
# remember current selected state machine id
currently_selected_sm_id = None
if self.model.get_selected_state_machine_model():
currently_selected_sm_id = self.model.get_selected_state_machine_model().state_machine.state_machine_id
# create a dictionary from state machine id to state machine path and one for tab page number for recovery
state_machine_path_by_sm_id = {}
page_num_by_sm_id = {}
for sm_id, sm in self.model.state_machine_manager.state_machines.items():
# the sm.base_path is only None if the state machine has never been loaded or saved before
if sm_id in state_machine_ids and sm.file_system_path is not None:
state_machine_path_by_sm_id[sm_id] = sm.file_system_path
page_num_by_sm_id[sm_id] = self.get_page_num(sm_id)
# close all state machine in list and remember if one was not closed
for sm_id in state_machine_ids:
was_closed = self.on_close_clicked(None, self.model.state_machines[sm_id], None, force=True)
if not was_closed and sm_id in page_num_by_sm_id:
logger.info("State machine with id {0} will not be re-open because was not closed.".format(sm_id))
del state_machine_path_by_sm_id[sm_id]
del page_num_by_sm_id[sm_id]
# reload state machines from file system
try:
self.model.state_machine_manager.open_state_machines(state_machine_path_by_sm_id)
except AttributeError as e:
logger.warning("Not all state machines were re-open because {0}".format(e))
import rafcon.gui.utils
rafcon.gui.utils.wait_for_gui() # TODO check again this is needed to secure that all sm-models are generated
# recover tab arrangement
self.rearrange_state_machines(page_num_by_sm_id)
# recover initial selected state machine and case handling if now state machine is open anymore
if currently_selected_sm_id:
# case if only unsaved state machines are open
if currently_selected_sm_id in self.model.state_machine_manager.state_machines:
self.set_active_state_machine(currently_selected_sm_id) | Refresh list af state machine tabs
:param list state_machine_ids: List of state machine ids to be refreshed
:return: | entailment |
def refresh_all_state_machines(self):
""" Refreshes all state machine tabs
"""
self.refresh_state_machines(list(self.model.state_machine_manager.state_machines.keys())) | Refreshes all state machine tabs | entailment |
def switch_state_machine_execution_engine(self, new_state_machine_execution_engine):
"""
Switch the state machine execution engine the main window controller listens to.
:param new_state_machine_execution_engine: the new state machine execution engine for this controller
:return:
"""
# relieve old one
self.relieve_model(self.state_machine_execution_model)
# register new
self.state_machine_execution_model = new_state_machine_execution_engine
self.observe_model(self.state_machine_execution_model) | Switch the state machine execution engine the main window controller listens to.
:param new_state_machine_execution_engine: the new state machine execution engine for this controller
:return: | entailment |
def execution_engine_model_changed(self, model, prop_name, info):
"""High light active state machine. """
notebook = self.view['notebook']
active_state_machine_id = self.model.state_machine_manager.active_state_machine_id
if active_state_machine_id is None:
# un-mark all state machine that are marked with execution-running style class
for tab in self.tabs.values():
label = notebook.get_tab_label(tab['page']).get_child().get_children()[0]
if label.get_style_context().has_class(constants.execution_running_style_class):
label.get_style_context().remove_class(constants.execution_running_style_class)
else:
# mark active state machine with execution-running style class
page = self.get_page_for_state_machine_id(active_state_machine_id)
if page:
label = notebook.get_tab_label(page).get_child().get_children()[0]
label.get_style_context().add_class(constants.execution_running_style_class) | High light active state machine. | entailment |
def get_state_tuple(state, state_m=None):
""" Generates a tuple that holds the state as yaml-strings and its meta data in a dictionary.
The tuple consists of:
[0] json_str for state,
[1] dict of child_state tuples,
[2] dict of model_meta-data of self and elements
[3] path of state in state machine
[4] script_text
[5] file system path
[6] semantic data
# states-meta - [state-, transitions-, data_flows-, outcomes-, inputs-, outputs-, scopes, states-meta]
:param rafcon.core.states.state.State state: The state that should be stored
:return: state_tuple tuple
"""
state_str = json.dumps(state, cls=JSONObjectEncoder,
indent=4, check_circular=False, sort_keys=True)
state_tuples_dict = {}
if isinstance(state, ContainerState):
# print(state.states, "\n")
for child_state_id, child_state in state.states.items():
# print("child_state: %s" % child_state_id, child_state, "\n")
state_tuples_dict[child_state_id] = get_state_tuple(child_state)
state_meta_dict = {} if state_m is None else get_state_element_meta(state_m)
script_content = state.script.script if isinstance(state, ExecutionState) else None
state_tuple = (state_str, state_tuples_dict, state_meta_dict, state.get_path(), script_content,
state.file_system_path, copy.deepcopy(state.semantic_data))
return state_tuple | Generates a tuple that holds the state as yaml-strings and its meta data in a dictionary.
The tuple consists of:
[0] json_str for state,
[1] dict of child_state tuples,
[2] dict of model_meta-data of self and elements
[3] path of state in state machine
[4] script_text
[5] file system path
[6] semantic data
# states-meta - [state-, transitions-, data_flows-, outcomes-, inputs-, outputs-, scopes, states-meta]
:param rafcon.core.states.state.State state: The state that should be stored
:return: state_tuple tuple | entailment |
def meta_dump_or_deepcopy(meta):
"""Function to observe meta data vivi-dict copy process and to debug it at one point"""
if DEBUG_META_REFERENCES: # debug copy
from rafcon.gui.helpers.meta_data import meta_data_reference_check
meta_data_reference_check(meta)
return copy.deepcopy(meta) | Function to observe meta data vivi-dict copy process and to debug it at one point | entailment |
def undo(self):
""" General Undo, that takes all elements in the parent and
:return:
"""
# logger.verbose("#H# STATE_MACHINE_UNDO STARTED")
state = self.state_machine.root_state
self.set_root_state_to_version(state, self.before_storage) | General Undo, that takes all elements in the parent and
:return: | entailment |
def get_cached_image(self, width, height, zoom, parameters=None, clear=False):
"""Get ImageSurface object, if possible, cached
The method checks whether the image was already rendered. This is done by comparing the passed size and
parameters with those of the last image. If they are equal, the cached image is returned. Otherwise,
a new ImageSurface with the specified dimensions is created and returned.
:param width: The width of the image
:param height: The height of the image
:param zoom: The current scale/zoom factor
:param parameters: The parameters used for the image
:param clear: If True, the cache is emptied, thus the image won't be retrieved from cache
:returns: The flag is True when the image is retrieved from the cache, otherwise False; The cached image
surface or a blank one with the desired size; The zoom parameter when the image was stored
:rtype: bool, ImageSurface, float
"""
global MAX_ALLOWED_AREA
if not parameters:
parameters = {}
if self.__compare_parameters(width, height, zoom, parameters) and not clear:
return True, self.__image, self.__zoom
# Restrict image surface size to prevent excessive use of memory
while True:
try:
self.__limiting_multiplicator = 1
area = width * zoom * self.__zoom_multiplicator * height * zoom * self.__zoom_multiplicator
if area > MAX_ALLOWED_AREA:
self.__limiting_multiplicator = sqrt(MAX_ALLOWED_AREA / area)
image = ImageSurface(self.__format, int(ceil(width * zoom * self.multiplicator)),
int(ceil(height * zoom * self.multiplicator)))
break # If we reach this point, the area was successfully allocated and we can break the loop
except Error:
MAX_ALLOWED_AREA *= 0.8
self.__set_cached_image(image, width, height, zoom, parameters)
return False, self.__image, zoom | Get ImageSurface object, if possible, cached
The method checks whether the image was already rendered. This is done by comparing the passed size and
parameters with those of the last image. If they are equal, the cached image is returned. Otherwise,
a new ImageSurface with the specified dimensions is created and returned.
:param width: The width of the image
:param height: The height of the image
:param zoom: The current scale/zoom factor
:param parameters: The parameters used for the image
:param clear: If True, the cache is emptied, thus the image won't be retrieved from cache
:returns: The flag is True when the image is retrieved from the cache, otherwise False; The cached image
surface or a blank one with the desired size; The zoom parameter when the image was stored
:rtype: bool, ImageSurface, float | entailment |
def copy_image_to_context(self, context, position, rotation=0, zoom=None):
"""Draw a cached image on the context
:param context: The Cairo context to draw on
:param position: The position od the image
"""
if not zoom:
zoom = self.__zoom
zoom_multiplicator = zoom * self.multiplicator
context.save()
context.scale(1. / zoom_multiplicator, 1. / zoom_multiplicator)
image_position = round(position[0] * zoom_multiplicator), round(position[1] * zoom_multiplicator)
context.translate(*image_position)
context.rotate(rotation)
context.set_source_surface(self.__image, 0, 0)
context.paint()
context.restore() | Draw a cached image on the context
:param context: The Cairo context to draw on
:param position: The position od the image | entailment |
def get_context_for_image(self, zoom):
"""Creates a temporary cairo context for the image surface
:param zoom: The current scaling factor
:return: Cairo context to draw on
"""
cairo_context = Context(self.__image)
cairo_context.scale(zoom * self.multiplicator, zoom * self.multiplicator)
return cairo_context | Creates a temporary cairo context for the image surface
:param zoom: The current scaling factor
:return: Cairo context to draw on | entailment |
def __compare_parameters(self, width, height, zoom, parameters):
"""Compare parameters for equality
Checks if a cached image is existing, the the dimensions agree and finally if the properties are equal. If
so, True is returned, else False,
:param width: The width of the image
:param height: The height of the image
:param zoom: The current scale/zoom factor
:param parameters: The parameters used for the image
:return: True if all parameters are equal, False else
"""
# Deactivated caching
if not global_gui_config.get_config_value('ENABLE_CACHING', True):
return False
# Empty cache
if not self.__image:
return False
# Changed image size
if self.__width != width or self.__height != height:
return False
# Current zoom greater then prepared zoom
if zoom > self.__zoom * self.__zoom_multiplicator:
return False
# Current zoom much smaller than prepared zoom, causes high memory usage and imperfect anti-aliasing
if zoom < self.__zoom / self.__zoom_multiplicator:
return False
# Changed drawing parameter
for key in parameters:
try:
if key not in self.__last_parameters or self.__last_parameters[key] != parameters[key]:
return False
except (AttributeError, ValueError):
# Some values cannot be compared and raise an exception on comparison (e.g. numpy.ndarray). In this
# case, just return False and do not cache.
try:
# Catch at least the ndarray-case, as this could occure relatively often
import numpy
if isinstance(self.__last_parameters[key], numpy.ndarray):
return numpy.array_equal(self.__last_parameters[key], parameters[key])
except ImportError:
return False
return False
return True | Compare parameters for equality
Checks if a cached image is existing, the the dimensions agree and finally if the properties are equal. If
so, True is returned, else False,
:param width: The width of the image
:param height: The height of the image
:param zoom: The current scale/zoom factor
:param parameters: The parameters used for the image
:return: True if all parameters are equal, False else | entailment |
def post_setup_plugins(parser_result):
"""Calls the post init hubs
:param dict parser_result: Dictionary with the parsed arguments
"""
if not isinstance(parser_result, dict):
parser_result = vars(parser_result)
plugins.run_post_inits(parser_result) | Calls the post init hubs
:param dict parser_result: Dictionary with the parsed arguments | entailment |
def setup_environment():
"""Ensures that the environmental variable RAFCON_LIB_PATH is existent
"""
try:
from gi.repository import GLib
user_data_folder = GLib.get_user_data_dir()
except ImportError:
user_data_folder = join(os.path.expanduser("~"), ".local", "share")
rafcon_root_path = dirname(realpath(rafcon.__file__))
user_library_folder = join(user_data_folder, "rafcon", "libraries")
# The RAFCON_LIB_PATH points to a path with common RAFCON libraries
# If the env variable is not set, we have to determine it. In the future, this should always be
# ~/.local/share/rafcon/libraries, but for backward compatibility, also a relative RAFCON path is supported
if not os.environ.get('RAFCON_LIB_PATH', None):
if exists(user_library_folder):
os.environ['RAFCON_LIB_PATH'] = user_library_folder
else:
os.environ['RAFCON_LIB_PATH'] = join(dirname(dirname(rafcon_root_path)), 'share', 'libraries')
# Install dummy _ builtin function in case i18.setup_l10n() is not called
if sys.version_info >= (3,):
import builtins as builtins23
else:
import __builtin__ as builtins23
if "_" not in builtins23.__dict__:
builtins23.__dict__["_"] = lambda s: s | Ensures that the environmental variable RAFCON_LIB_PATH is existent | entailment |
def parse_state_machine_path(path):
"""Parser for argparse checking pfor a proper state machine path
:param str path: Input path from the user
:return: The path
:raises argparse.ArgumentTypeError: if the path does not contain a statemachine.json file
"""
sm_root_file = join(path, storage.STATEMACHINE_FILE)
if exists(sm_root_file):
return path
else:
sm_root_file = join(path, storage.STATEMACHINE_FILE_OLD)
if exists(sm_root_file):
return path
raise argparse.ArgumentTypeError("Failed to open {0}: {1} not found in path".format(path,
storage.STATEMACHINE_FILE)) | Parser for argparse checking pfor a proper state machine path
:param str path: Input path from the user
:return: The path
:raises argparse.ArgumentTypeError: if the path does not contain a statemachine.json file | entailment |
def setup_argument_parser():
"""Sets up teh parser with the required arguments
:return: The parser object
"""
default_config_path = filesystem.get_default_config_path()
filesystem.create_path(default_config_path)
parser = core_singletons.argument_parser
parser.add_argument('-o', '--open', type=parse_state_machine_path, dest='state_machine_path', metavar='path',
nargs='+', help="specify directories of state-machines that shall be opened. The path must "
"contain a statemachine.json file")
parser.add_argument('-c', '--config', type=config_path, metavar='path', dest='config_path',
default=default_config_path, nargs='?', const=default_config_path,
help="path to the configuration file config.yaml. Use 'None' to prevent the generation of "
"a config file and use the default configuration. Default: {0}".format(default_config_path))
parser.add_argument('-r', '--remote', action='store_true', help="remote control mode")
parser.add_argument('-s', '--start_state_path', metavar='path', dest='start_state_path', default=None, nargs='?',
help="path within a state machine to the state that should be launched. The state path "
"consists of state ids (e.g. QPOXGD/YVWJKZ whereof QPOXGD is the root state and YVWJKZ "
"it's child state to start from).")
return parser | Sets up teh parser with the required arguments
:return: The parser object | entailment |
def setup_configuration(config_path):
"""Loads the core configuration from the specified path and uses its content for further setup
:param config_path: Path to the core config file
"""
if config_path is not None:
config_path, config_file = filesystem.separate_folder_path_and_file_name(config_path)
global_config.load(config_file=config_file, path=config_path)
else:
global_config.load(path=config_path)
# Initialize libraries
core_singletons.library_manager.initialize() | Loads the core configuration from the specified path and uses its content for further setup
:param config_path: Path to the core config file | entailment |
def open_state_machine(state_machine_path):
"""Executes the specified state machine
:param str state_machine_path: The file path to the state machine
:return StateMachine: The loaded state machine
"""
sm = storage.load_state_machine_from_path(state_machine_path)
core_singletons.state_machine_manager.add_state_machine(sm)
return sm | Executes the specified state machine
:param str state_machine_path: The file path to the state machine
:return StateMachine: The loaded state machine | entailment |
def wait_for_state_machine_finished(state_machine):
""" wait for a state machine to finish its execution
:param state_machine: the statemachine to synchronize with
:return:
"""
global _user_abort
from rafcon.core.states.execution_state import ExecutionState
if not isinstance(state_machine.root_state, ExecutionState):
while len(state_machine.execution_histories[0]) < 1:
time.sleep(0.1)
else:
time.sleep(0.5)
while state_machine.root_state.state_execution_status is not StateExecutionStatus.INACTIVE:
try:
state_machine.root_state.concurrency_queue.get(timeout=1)
# this check triggers if the state machine could not be stopped in the signal handler
if _user_abort:
return
except Empty:
pass
# no logger output here to make it easier for the parser
logger.verbose("RAFCON live signal") | wait for a state machine to finish its execution
:param state_machine: the statemachine to synchronize with
:return: | entailment |
def stop_reactor_on_state_machine_finish(state_machine):
""" Wait for a state machine to be finished and stops the reactor
:param state_machine: the state machine to synchronize with
"""
wait_for_state_machine_finished(state_machine)
from twisted.internet import reactor
if reactor.running:
plugins.run_hook("pre_destruction")
reactor.callFromThread(reactor.stop) | Wait for a state machine to be finished and stops the reactor
:param state_machine: the state machine to synchronize with | entailment |
async def wait_until_ready(
self, timeout: Optional[float] = None, no_raise: bool = False
) -> bool:
"""
Waits for the underlying node to become ready.
If no_raise is set, returns false when a timeout occurs instead of propogating TimeoutError.
A timeout of None means to wait indefinitely.
"""
if self.node.ready.is_set():
return True
try:
return await self.node.wait_until_ready(timeout=timeout)
except asyncio.TimeoutError:
if no_raise:
return False
else:
raise | Waits for the underlying node to become ready.
If no_raise is set, returns false when a timeout occurs instead of propogating TimeoutError.
A timeout of None means to wait indefinitely. | entailment |
async def connect(self):
"""
Connects to the voice channel associated with this Player.
"""
await self.node.join_voice_channel(self.channel.guild.id, self.channel.id) | Connects to the voice channel associated with this Player. | entailment |
async def move_to(self, channel: discord.VoiceChannel):
"""
Moves this player to a voice channel.
Parameters
----------
channel : discord.VoiceChannel
"""
if channel.guild != self.channel.guild:
raise TypeError("Cannot move to a different guild.")
self.channel = channel
await self.connect() | Moves this player to a voice channel.
Parameters
----------
channel : discord.VoiceChannel | entailment |
async def disconnect(self, requested=True):
"""
Disconnects this player from it's voice channel.
"""
if self.state == PlayerState.DISCONNECTING:
return
await self.update_state(PlayerState.DISCONNECTING)
if not requested:
log.debug(
f"Forcing player disconnect for guild {self.channel.guild.id}"
f" due to player manager request."
)
guild_id = self.channel.guild.id
voice_ws = self.node.get_voice_ws(guild_id)
if not voice_ws.closed:
await voice_ws.voice_state(guild_id, None)
await self.node.destroy_guild(guild_id)
await self.close()
self.manager.remove_player(self) | Disconnects this player from it's voice channel. | entailment |
async def handle_event(self, event: "node.LavalinkEvents", extra):
"""
Handles various Lavalink Events.
If the event is TRACK END, extra will be TrackEndReason.
If the event is TRACK EXCEPTION, extra will be the string reason.
If the event is TRACK STUCK, extra will be the threshold ms.
Parameters
----------
event : node.LavalinkEvents
extra
"""
if event == LavalinkEvents.TRACK_END:
if extra == TrackEndReason.FINISHED:
await self.play()
else:
self._is_playing = False | Handles various Lavalink Events.
If the event is TRACK END, extra will be TrackEndReason.
If the event is TRACK EXCEPTION, extra will be the string reason.
If the event is TRACK STUCK, extra will be the threshold ms.
Parameters
----------
event : node.LavalinkEvents
extra | entailment |
async def handle_player_update(self, state: "node.PlayerState"):
"""
Handles player updates from lavalink.
Parameters
----------
state : websocket.PlayerState
"""
if state.position > self.position:
self._is_playing = True
self.position = state.position | Handles player updates from lavalink.
Parameters
----------
state : websocket.PlayerState | entailment |
def add(self, requester: discord.User, track: Track):
"""
Adds a track to the queue.
Parameters
----------
requester : discord.User
User who requested the track.
track : Track
Result from any of the lavalink track search methods.
"""
track.requester = requester
self.queue.append(track) | Adds a track to the queue.
Parameters
----------
requester : discord.User
User who requested the track.
track : Track
Result from any of the lavalink track search methods. | entailment |
async def play(self):
"""
Starts playback from lavalink.
"""
if self.repeat and self.current is not None:
self.queue.append(self.current)
self.current = None
self.position = 0
self._paused = False
if not self.queue:
await self.stop()
else:
self._is_playing = True
if self.shuffle:
track = self.queue.pop(randrange(len(self.queue)))
else:
track = self.queue.pop(0)
self.current = track
log.debug("Assigned current.")
await self.node.play(self.channel.guild.id, track) | Starts playback from lavalink. | entailment |
async def stop(self):
"""
Stops playback from lavalink.
.. important::
This method will clear the queue.
"""
await self.node.stop(self.channel.guild.id)
self.queue = []
self.current = None
self.position = 0
self._paused = False | Stops playback from lavalink.
.. important::
This method will clear the queue. | entailment |
async def pause(self, pause: bool = True):
"""
Pauses the current song.
Parameters
----------
pause : bool
Set to ``False`` to resume.
"""
self._paused = pause
await self.node.pause(self.channel.guild.id, pause) | Pauses the current song.
Parameters
----------
pause : bool
Set to ``False`` to resume. | entailment |
async def set_volume(self, volume: int):
"""
Sets the volume of Lavalink.
Parameters
----------
volume : int
Between 0 and 150
"""
self._volume = max(min(volume, 150), 0)
await self.node.volume(self.channel.guild.id, self.volume) | Sets the volume of Lavalink.
Parameters
----------
volume : int
Between 0 and 150 | entailment |
async def seek(self, position: int):
"""
If the track allows it, seeks to a position.
Parameters
----------
position : int
Between 0 and track length.
"""
if self.current.seekable:
position = max(min(position, self.current.length), 0)
await self.node.seek(self.channel.guild.id, position) | If the track allows it, seeks to a position.
Parameters
----------
position : int
Between 0 and track length. | entailment |
async def create_player(self, channel: discord.VoiceChannel) -> Player:
"""
Connects to a discord voice channel.
This function is safe to repeatedly call as it will return an existing
player if there is one.
Parameters
----------
channel
Returns
-------
Player
The created Player object.
"""
if self._already_in_guild(channel):
p = self.get_player(channel.guild.id)
await p.move_to(channel)
else:
p = Player(self, channel)
await p.connect()
self._player_dict[channel.guild.id] = p
await self.refresh_player_state(p)
return p | Connects to a discord voice channel.
This function is safe to repeatedly call as it will return an existing
player if there is one.
Parameters
----------
channel
Returns
-------
Player
The created Player object. | entailment |
def get_player(self, guild_id: int) -> Player:
"""
Gets a Player object from a guild ID.
Parameters
----------
guild_id : int
Discord guild ID.
Returns
-------
Player
Raises
------
KeyError
If that guild does not have a Player, e.g. is not connected to any
voice channel.
"""
if guild_id in self._player_dict:
return self._player_dict[guild_id]
raise KeyError("No such player for that guild.") | Gets a Player object from a guild ID.
Parameters
----------
guild_id : int
Discord guild ID.
Returns
-------
Player
Raises
------
KeyError
If that guild does not have a Player, e.g. is not connected to any
voice channel. | entailment |
async def disconnect(self):
"""
Disconnects all players.
"""
for p in tuple(self.players):
await p.disconnect(requested=False)
log.debug("Disconnected players.") | Disconnects all players. | entailment |
def resource_filename(package_or_requirement, resource_name):
"""
Similar to pkg_resources.resource_filename but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: the path to the resource
:rtype: str
"""
if pkg_resources.resource_exists(package_or_requirement, resource_name):
return pkg_resources.resource_filename(package_or_requirement, resource_name)
path = _search_in_share_folders(package_or_requirement, resource_name)
if path:
return path
raise RuntimeError("Resource {} not found in {}".format(package_or_requirement, resource_name)) | Similar to pkg_resources.resource_filename but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: the path to the resource
:rtype: str | entailment |
def resource_exists(package_or_requirement, resource_name):
"""
Similar to pkg_resources.resource_exists but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: a flag if the file exists
:rtype: bool
"""
if pkg_resources.resource_exists(package_or_requirement, resource_name):
return True
path = _search_in_share_folders(package_or_requirement, resource_name)
return True if path else False | Similar to pkg_resources.resource_exists but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: a flag if the file exists
:rtype: bool | entailment |
def resource_string(package_or_requirement, resource_name):
"""
Similar to pkg_resources.resource_string but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: the file content
:rtype: str
"""
with open(resource_filename(package_or_requirement, resource_name), 'r') as resource_file:
return resource_file.read() | Similar to pkg_resources.resource_string but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param resource_name: the name of the resource
:return: the file content
:rtype: str | entailment |
def resource_listdir(package_or_requirement, relative_path):
"""
Similar to pkg_resources.resource_listdir but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param relative_path: the relative path to the resource
:return: a list of all files residing in the target path
:rtype: list
"""
path = resource_filename(package_or_requirement, relative_path)
only_files = [f for f in listdir(path) if isfile(join(path, f))]
return only_files | Similar to pkg_resources.resource_listdir but if the resource it not found via pkg_resources
it also looks in a predefined list of paths in order to find the resource
:param package_or_requirement: the module in which the resource resides
:param relative_path: the relative path to the resource
:return: a list of all files residing in the target path
:rtype: list | entailment |
def load_plugins():
"""Loads all plugins specified in the RAFCON_PLUGIN_PATH environment variable
"""
plugins = os.environ.get('RAFCON_PLUGIN_PATH', '')
plugin_list = set(plugins.split(os.pathsep))
global plugin_dict
for plugin_path in plugin_list:
if not plugin_path:
continue
plugin_path = os.path.expandvars(os.path.expanduser(plugin_path)).strip()
if not os.path.exists(plugin_path):
logger.error("The specified plugin path does not exist: {}".format(plugin_path))
continue
dir_name, plugin_name = os.path.split(plugin_path.rstrip('/'))
logger.info("Found plugin '{}' at {}".format(plugin_name, plugin_path))
sys.path.insert(0, dir_name)
if plugin_name in plugin_dict:
logger.error("Plugin '{}' already loaded".format(plugin_name))
else:
try:
module = importlib.import_module(plugin_name)
plugin_dict[plugin_name] = module
logger.info("Successfully loaded plugin '{}'".format(plugin_name))
except ImportError as e:
logger.error("Could not import plugin '{}': {}\n{}".format(plugin_name, e, str(traceback.format_exc()))) | Loads all plugins specified in the RAFCON_PLUGIN_PATH environment variable | entailment |
def run_hook(hook_name, *args, **kwargs):
"""Runs the passed hook on all registered plugins
The function checks, whether the hook is available in the plugin.
:param hook_name: Name of the hook, corresponds to the function name being called
:param args: Arguments
:param kwargs: Keyword arguments
"""
for module in plugin_dict.values():
if hasattr(module, "hooks") and callable(getattr(module.hooks, hook_name, None)):
getattr(module.hooks, hook_name)(*args, **kwargs) | Runs the passed hook on all registered plugins
The function checks, whether the hook is available in the plugin.
:param hook_name: Name of the hook, corresponds to the function name being called
:param args: Arguments
:param kwargs: Keyword arguments | entailment |
def get_state_model_class_for_state(state):
"""Determines the model required for the given state class
:param state: Instance of a state (ExecutionState, BarrierConcurrencyState, ...)
:return: The model class required for holding such a state instance
"""
from rafcon.gui.models.state import StateModel
from rafcon.gui.models.container_state import ContainerStateModel
from rafcon.gui.models.library_state import LibraryStateModel
if isinstance(state, ContainerState):
return ContainerStateModel
elif isinstance(state, LibraryState):
return LibraryStateModel
elif isinstance(state, State):
return StateModel
else:
logger.warning("There is not model for state of type {0} {1}".format(type(state), state))
return None | Determines the model required for the given state class
:param state: Instance of a state (ExecutionState, BarrierConcurrencyState, ...)
:return: The model class required for holding such a state instance | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.