MVC Models: rafcon.gui.models
¶
This package contains all models of the MVC architecture.
The models hold the data for, which are shown in the views. These models typically hold an element of the core, which is observable. For example, the StateModel holds a reference to a State class object from the core. If the core element changes, the model recognizes these changes and forwards the notification to the controllers, if they observe the changed model property.
AbstractStateModel (in abstract_state)¶
- class rafcon.gui.models.abstract_state.AbstractStateModel(state, parent=None, meta=None)¶
Bases:
MetaModel
,Hashable
This is an abstract class serving as base class for state models
The model class is part of the MVC architecture. It holds the data to be shown (in this case a state).
- Parameters:
state – The state to be managed which can be any derivative of rafcon.core.states.state.State.
parent (AbstractStateModel) – The state to be managed
meta (rafcon.utils.vividict.Vividict) – The meta data of the state
- property action_signal¶
- action_signal_triggered(model, prop_name, info)¶
This method notifies the parent state and child state models about complex actions
- child_model_changed(notification_overview)¶
- copy_meta_data_from_state_m(source_state_m)¶
Dismiss current meta data and copy meta data from given state model
The meta data of the given state model is used as meta data for this state. Also the meta data of all state elements (data ports, outcomes, etc.) is overwritten with the meta data of the elements of the given state.
- Parameters:
source_state_m – State model to load the meta data from
- property core_element¶
- property destruction_signal¶
- get_data_port_m(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.
- Parameters:
data_port_id – The data port id to be searched
- Returns:
The model of the data port or None if it is not found
- get_input_data_port_m(data_port_id)¶
Returns the input data port model for the given data port id
- Parameters:
data_port_id – The data port id to search for
- Returns:
The model of the data port with the given id
- get_observable_action_signal()¶
- get_observable_destruction_signal()¶
- get_observable_income()¶
- get_observable_input_data_ports()¶
- get_observable_is_start()¶
- get_observable_meta_signal()¶
- get_observable_outcomes()¶
- get_observable_output_data_ports()¶
- get_observable_state()¶
- get_outcome_m(outcome_id)¶
Returns the outcome model for the given outcome id
- Parameters:
outcome_id – The outcome id to search for
- Returns:
The model of the outcome with the given id
- get_output_data_port_m(data_port_id)¶
Returns the output data port model for the given data port id
- Parameters:
data_port_id – The data port id to search for
- Returns:
The model of the data port with the given id
- get_state_machine_m(two_factor_check=True)¶
Get respective state machine model
Get a reference of the state machine model the state model belongs to. As long as the root state model has no direct reference to its state machine model the state machine manager model is checked respective model.
- Return type:
- Returns:
respective state machine model
- property hierarchy_level¶
- property income¶
- property input_data_ports¶
- property is_about_to_be_destroyed_recursively¶
- property is_start¶
- load_meta_data(path=None)¶
Load meta data of state model from the file system
The meta data of the state model is loaded from the file system and stored in the meta property of the model. Existing meta data is removed. Also the meta data of all state elements (data ports, outcomes, etc) are loaded, as those stored in the same file as the meta data of the state.
This is either called on the __init__ of a new state model or if a state model for a container state is created, which then calls load_meta_data for all its children.
- meta_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the meta data
- property meta_signal¶
- model_changed(model, prop_name, info)¶
This method notifies parent state about changes made to the state
- property outcomes¶
- property output_data_ports¶
- property parent¶
- prepare_destruction(recursive=True)¶
Prepares the model for destruction
Recursively un-registers all observers and removes references to child models
- set_observable_action_signal(value)¶
- set_observable_destruction_signal(value)¶
- set_observable_income(value)¶
- set_observable_input_data_ports(value)¶
- set_observable_is_start(value)¶
- set_observable_meta_signal(value)¶
- set_observable_outcomes(value)¶
- set_observable_output_data_ports(value)¶
- set_observable_state(value)¶
- property state¶
- state_counter = 0¶
- store_meta_data(copy_path=None)¶
Save meta data of state model to the file system
This method generates a dictionary of the meta data of the state together with the meta data of all state elements (data ports, outcomes, etc.) and stores it on the filesystem. Secure that the store meta data method is called after storing the core data otherwise the last_stored_path is maybe wrong or None. The copy path is considered to be a state machine file system path but not the current one but e.g. of a as copy saved state machine. The meta data will be stored in respective relative state folder in the state machine hierarchy. This folder has to exist. Dues the core elements of the state machine has to be stored first.
- Parameters:
copy_path (str) – Optional copy path if meta data is not stored to the file system path of state machine
- update_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
- update_is_start()¶
Updates the is_start property of the state
A state is a start state, if it is the root state, it has no parent, the parent is a LibraryState or the state’s state_id is identical with the ContainerState.start_state_id of the ContainerState it is within.
- update_meta_data_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their meta data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
- rafcon.gui.models.abstract_state.get_state_model_class_for_state(state)¶
Determines the model required for the given state class
- Parameters:
state – Instance of a state (ExecutionState, BarrierConcurrencyState, …)
- Returns:
The model class required for holding such a state instance
- rafcon.gui.models.abstract_state.mirror_y_axis_in_vividict_element(vividict, key)¶
StateModel (in state)¶
- class rafcon.gui.models.state.StateModel(state, parent=None, meta=None, load_meta_data=True, expected_future_models=None)¶
Bases:
AbstractStateModel
This model class manages a State, for the moment only ExecutionStates
The model class is part of the MVC architecture. It holds the data to be shown (in this case a state).
- Parameters:
state (rafcon.core.states.state.State) – The state to be managed
parent (AbstractStateModel) – The state to be managed
meta (rafcon.utils.vividict.Vividict) – The meta data of the state
expected_future_models (__buildIn__.set) – Existing models for new core elements
- add_missing_model(model_list_or_dict, core_elements_dict, model_name, model_class, model_key)¶
Adds one missing model
The method will search for the first core-object out of core_object_dict not represented in the list or dict of models handed by model_list_or_dict, adds it and returns without continue to search for more objects which maybe are missing in model_list_or_dict with respect to the core_object_dict.
- Parameters:
model_list_or_dict – could be a list or dictionary of one model type
core_elements_dict – dictionary of one type of core-elements (rafcon.core)
model_name – prop_name for the core-element hold by the model, this core-element is covered by the model
model_class – model-class of the elements that should be insert
model_key – if model_list_or_dict is a dictionary the key is the id of the respective element (e.g. ‘state_id’)
- Returns:
True, is a new model was added, False else
- Return type:
- expected_future_models = None¶
- get_cause_and_affected_model_list(model)¶
- get_model_info(model)¶
- 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 (outcomes, ports) 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 method that caused the change. In the following, it notifies the list in which the change happened about the change. E.g. one input data port changes its name. The model of the port observes itself and notifies the parent ( i.e. the state model) about the change by calling this method with the information about the change. This method recognizes that the method “modify_input_data_port” caused the change and therefore triggers a notify on the list if input data port models. “notify_before” is used as trigger method when the changing function is entered and “notify_after” is used when the changing function returns. This changing function in the example would be “modify_input_data_port”.
- Parameters:
model – The model that was changed
prop_name – The property that was changed
info – Information about the change (e.g. the name of the changing function)
- re_initiate_model_list(model_list_or_dict, core_objects_dict, model_name, model_class, model_key)¶
Recreate model list
The method re-initiate a handed list or dictionary of models with the new dictionary of core-objects.
- Parameters:
model_list_or_dict – could be a list or dictionary of one model type
core_objects_dict – new dictionary of one type of core-elements (rafcon.core)
model_name – prop_name for the core-element hold by the model, this core-element is covered by the model
model_class – model-class of the elements that should be insert
model_key – if model_list_or_dict is a dictionary the key is the id of the respective element (e.g. ‘state_id’)
- Returns:
- remove_additional_model(model_list_or_dict, core_objects_dict, model_name, model_key, destroy=True)¶
Remove one unnecessary model
The method will search for the first model-object out of model_list_or_dict that represents no core-object in the dictionary of core-objects handed by core_objects_dict, remove it and return without continue to search for more model-objects which maybe are unnecessary, too.
- Parameters:
model_list_or_dict – could be a list or dictionary of one model type
core_objects_dict – dictionary of one type of core-elements (rafcon.core)
model_name – prop_name for the core-element hold by the model, this core-element is covered by the model
model_key – if model_list_or_dict is a dictionary the key is the id of the respective element (e.g. ‘state_id’)
- Returns:
- remove_specific_model(model_list_or_dict, core_element, model_key=None, recursive=True, destroy=True)¶
- update_models(model, name, info)¶
This method is always triggered when the core state changes
It keeps the following models/model-lists consistent: input-data-port models output-data-port models outcome models
ContainerStateModel (in container_state)¶
- class rafcon.gui.models.container_state.ContainerStateModel(container_state, parent=None, meta=None, load_meta_data=True, expected_future_models=None)¶
Bases:
StateModel
This model class manages a ContainerState
The model class is part of the MVC architecture. It holds the data to be shown (in this case a container state).
- Parameters:
container_state (ContainerState) – The container state to be managed
- 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.
- Parameters:
source_state_m – State model to load the meta data from
- property data_flows¶
- get_cause_and_affected_model_list(model)¶
- get_data_flow_m(data_flow_id)¶
Searches and return the data flow model with the given in the given container state model
- Parameters:
data_flow_id – The data flow id to be searched
- Returns:
The model of the data flow or None if it is not found
- get_data_port_m(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.
- Parameters:
data_port_id – The data port id to be searched
- Returns:
The model of the data port or None if it is not found
- get_observable_data_flows()¶
- get_observable_scoped_variables()¶
- get_observable_states()¶
- get_observable_transitions()¶
- get_scoped_variable_m(data_port_id)¶
Returns the scoped variable model for the given data port id
- Parameters:
data_port_id – The data port id to search for
- Returns:
The model of the scoped variable with the given id
- get_transition_m(transition_id)¶
Searches and return the transition model with the given in the given container state model
- Parameters:
transition_id – The transition id to be searched
- Returns:
The model of the transition or None if it is not found
- group_states(model, prop_name, info)¶
- insert_meta_data_from_models_dict(source_models_dict, notify_logger_method)¶
- 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_before” is used as trigger method when the changing function is entered and “notify_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)
- prepare_destruction(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.
- property scoped_variables¶
- set_observable_data_flows(value)¶
- set_observable_scoped_variables(value)¶
- set_observable_states(value)¶
- set_observable_transitions(value)¶
- property states¶
- store_meta_data(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.
- Parameters:
copy_path (str) – Optional copy path if meta data is not stored to the file system path of state machine
- substitute_state(model, prop_name, info)¶
- property transitions¶
- ungroup_state(model, prop_name, info)¶
- update_child_is_start()¶
Updates the is_child property of its child states
- update_child_models(_, 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_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
- update_meta_data_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their meta data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
LibraryStateModel (in library_state)¶
- class rafcon.gui.models.library_state.LibraryStateModel(state, parent=None, meta=None, load_meta_data=True)¶
Bases:
AbstractStateModel
This model class manages a LibraryState
The model class is part of the MVC architecture. It holds the data to be shown (in this case a state).
- Parameters:
state (rafcon.core.states.library_state.LibraryState) – The state to be managed
- copy_meta_data_from_state_m(source_state_m)¶
Dismiss current meta data and copy meta data from given state model
The meta data of the given state model is used as meta data for this state. Also the meta data of all state elements (data ports, outcomes, etc.) is overwritten with the meta data of the elements of the given state.
- Parameters:
source_state_m – State model to load the meta data from
- enforce_generation_of_state_copy_model()¶
This enforce a load of state copy model without considering meta data
- initiate_library_root_state_model()¶
- property is_about_to_be_destroyed_recursively¶
- model_changed(model, prop_name, info)¶
This method notifies parent state about changes made to the state
- prepare_destruction(recursive=True)¶
Prepares the model for destruction
Recursively un-registers all observers and removes references to child models
- recursive_generate_models(load_meta_data)¶
- show_content()¶
Check if content of library is to be shown
Content is shown, if the uppermost state’s meta flag “show_content” is True and the library hierarchy depth (up to MAX_VISIBLE_LIBRARY_HIERARCHY level) is not to high.
- Returns:
Whether the content is to be shown
- Return type:
- state_copy = None¶
- update_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
StateElementModel (in state_element)¶
- class rafcon.gui.models.state_element.StateElementModel(parent, meta=None)¶
Bases:
MetaModel
,Hashable
This model class serves as base class for all models within a state model (ports, connections)
Each state element model has a parent, meta and temp data. If observes itself and informs the parent about changes.
- Parameters:
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- property destruction_signal¶
- get_observable_destruction_signal()¶
- get_observable_meta_signal()¶
- get_state_machine_m()¶
- meta_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the meta data
- property meta_signal¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- property parent¶
Getter for the parent state model of the state element
- Returns:
None if parent is not defined, else the model of the parent state
- Return type:
rafcon.gui.models.abstract_state.AbstractState
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- set_observable_destruction_signal(value)¶
- set_observable_meta_signal(value)¶
- update_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
TransitionModel (in transition)¶
- class rafcon.gui.models.transition.TransitionModel(transition, parent, meta=None)¶
Bases:
StateElementModel
This model class manages a Transition
- Parameters:
transition (rafcon.core.transition.Transition) – The transition to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- get_observable_transition()¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- set_observable_transition(value)¶
- property transition¶
- rafcon.gui.models.transition.mirror_waypoints(vividict)¶
DataFlowModel (in data_flow)¶
- class rafcon.gui.models.data_flow.DataFlowModel(data_flow, parent, meta=None)¶
Bases:
StateElementModel
This model class manages a DataFlow
- Parameters:
data_flow (rafcon.core.data_flow.DataFlow) – The data flow to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- property data_flow¶
- get_observable_data_flow()¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- set_observable_data_flow(value)¶
DataPortModel (in data_port)¶
- class rafcon.gui.models.data_port.DataPortModel(data_port, parent, meta=None)¶
Bases:
StateElementModel
This model class manages a DataPort
- Parameters:
data_port (rafcon.core.data_port.DataPort) – The input/output data port to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- property data_port¶
- get_observable_data_port()¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- set_observable_data_port(value)¶
ScopedVariableModel (in scoped_variable)¶
- class rafcon.gui.models.scoped_variable.ScopedVariableModel(scoped_variable, parent, meta=None)¶
Bases:
StateElementModel
This model class manages a ScopedVariable
- Parameters:
scoped_variable (rafcon.core.scoped_variable.ScopedVariable) – The scoped variable to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- get_observable_scoped_variable()¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- property scoped_variable¶
- set_observable_scoped_variable(value)¶
Selection (in selection)¶
- class rafcon.gui.models.selection.Selection(parent_signal=None)¶
Bases:
ModelMT
This class contains the selected models of a state_machine
- add(*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..
- clear(*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..
- property data_flows¶
Returns all selected data flows
- Returns:
Subset of the selection, only containing data flows
- Return type:
- property focus¶
Returns the currently focused element
- property focus_signal¶
- get_all()¶
Return a copy of the selection
- Returns:
Copy of the set of selected elements
- Return type:
- get_observable_focus_signal()¶
- get_observable_selection_changed_signal()¶
- get_selected_elements_of_core_class(core_element_type)¶
Returns all selected elements having the specified core_element_type as state element class
- Returns:
Subset of the selection, only containing elements having core_element_type as state element class
- Return type:
- get_selected_state()¶
Return the first state within the selection
- Returns:
First state within the selection or None if there is none
- Return type:
- handle_new_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..
- handle_prepared_selection_of_core_class_elements(*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..
- property income¶
Alias for
incomes()
- property incomes¶
Returns all selected incomes
- Returns:
Subset of the selection, only containing incomes
- Return type:
- property input_data_ports¶
Returns all selected input data ports
- Returns:
Subset of the selection, only containing input data ports
- Return type:
- is_selected(model)¶
Checks whether the given model is selected
- Parameters:
model –
- Returns:
True if the model is within the selection, False else
- Return type:
- on_model_destruct(destructed_model, signal, info)¶
Deselect models that are being destroyed
- property outcomes¶
Returns all selected outcomes
- Returns:
Subset of the selection, only containing outcomes
- Return type:
- property output_data_ports¶
Returns all selected output data ports
- Returns:
Subset of the selection, only containing output data ports
- Return type:
- remove(*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..
- property scoped_variables¶
Returns all selected scoped variables
- Returns:
Subset of the selection, only containing scoped variables
- Return type:
- property selection_changed_signal¶
- set(*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..
- set_observable_focus_signal(value)¶
- set_observable_selection_changed_signal(value)¶
- property states¶
Returns all selected states
- Returns:
Subset of the selection, only containing states
- Return type:
- property transitions¶
Returns all selected transitions
- Returns:
Subset of the selection, only containing transitions
- Return type:
- update_core_element_lists()¶
Maintains inner lists of selected elements with a specific core element class
- rafcon.gui.models.selection.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.
- Returns:
If to extend the selection
- Return type:
True
- rafcon.gui.models.selection.reduce_to_parent_states(models)¶
Remove all state models that also have their parents 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.
- rafcon.gui.models.selection.updates_selection(update_selection)¶
Decorator indicating that the decorated method could change the selection
LogicalPortModel (in logical_port)¶
- class rafcon.gui.models.logical_port.IncomeModel(income, parent, meta=None)¶
Bases:
LogicalPortModel
This model class manages an Income
- Parameters:
income (rafcon.core.logical_port.Income) – The income to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- get_observable_income()¶
- property income¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- set_observable_income(value)¶
- class rafcon.gui.models.logical_port.LogicalPortModel(parent, meta=None)¶
Bases:
StateElementModel
This model class serves as base class for all logical ports
- class rafcon.gui.models.logical_port.OutcomeModel(outcome, parent, meta=None)¶
Bases:
LogicalPortModel
This model class manages an Outcome
- Parameters:
outcome (rafcon.core.logical_port.Outcome) – The outcome to be wrapped
parent (rafcon.gui.models.abstract_state.AbstractStateModel) – The state model of the state element
meta (rafcon.utils.vividict.Vividict) – The meta data of the state element model
- property core_element¶
Return the core element represented by this model
- Returns:
core element of the model
- Return type:
- get_observable_outcome()¶
- model_changed(model, prop_name, info)¶
This method notifies the parent state about changes made to the state element
- property outcome¶
- prepare_destruction()¶
Prepares the model for destruction
Unregisters the model from observing itself.
- set_observable_outcome(value)¶
StateMachineModel (in state_machine)¶
- class rafcon.gui.models.state_machine.ComplexActionObserver(model)¶
Bases:
Observer
This Observer observes the and structures the information of complex actions and separates those observations from the StateMachineModel to avoid to mix these with the root state observation of the state machine model.
In ongoing_complex_actions dictionary all active actions and there properties are hold
Only once at the end of an complex action the ongoing_complex_actions dictionary is empty and the nested_action_already_in list has elements in to secure accessibility of action properties in the pattern
The nested_action_already_in list is cleaned after the ongoing_complex_actions dictionary was cleared observable
- action_signal(model, prop_name, info)¶
- property ongoing_complex_actions¶
- state_action_signal(model, prop_name, info)¶
- class rafcon.gui.models.state_machine.StateMachineModel(**kwargs)¶
Bases:
MetaModel
,Hashable
This model class manages a
rafcon.core.state_machine.StateMachine
The model class is part of the MVC architecture. It holds the data to be shown (in this case a state machine).
- Parameters:
state_machine (StateMachine) – The state machine to be controlled and modified
- property action_signal¶
- action_signal_triggered(model, prop_name, info)¶
When the action was performed, we have to set the dirty flag, as the changes are unsaved
- change_root_state_type(model, prop_name, info)¶
- property core_element¶
- destroy()¶
- property destruction_signal¶
- get_observable_action_signal()¶
- get_observable_destruction_signal()¶
- get_observable_meta_signal()¶
- get_observable_ongoing_complex_actions()¶
- get_observable_root_state()¶
- get_observable_sm_selection_changed_signal()¶
- get_observable_state_action_signal()¶
- get_observable_state_machine()¶
- get_observable_state_meta_signal()¶
- get_state_model_by_path(path)¶
Returns the StateModel for the given path
Searches a StateModel in the state machine, who’s path is given by path.
- Parameters:
path (str) – Path of the searched state
- Returns:
The state with that path
- Return type:
- Raises:
ValueError, if path is invalid/not existing with this state machine
- load_meta_data(path=None, recursively=True)¶
Load meta data of state machine model from the file system
The meta data of the state machine model is loaded from the file system and stored in the meta property of the model. Existing meta data is removed. Also the meta data of root state and children is loaded.
- Parameters:
path (str) – Optional path to the meta data file. If not given, the path will be derived from the state machine’s path on the filesystem
- meta = None¶
- meta_changed(model, prop_name, info)¶
When the meta was changed, we have to set the dirty flag, as the changes are unsaved
- property meta_signal¶
- property ongoing_complex_actions¶
- prepare_destruction()¶
Prepares the model for destruction
Unregister itself as observer from the state machine and the root state
- property root_state¶
- root_state_assign(model, prop_name, info)¶
- root_state_model_after_change(model, prop_name, info)¶
- root_state_model_before_change(model, prop_name, info)¶
- selection = None¶
- set_observable_action_signal(value)¶
- set_observable_destruction_signal(value)¶
- set_observable_meta_signal(value)¶
- set_observable_ongoing_complex_actions(value)¶
- set_observable_root_state(value)¶
- set_observable_sm_selection_changed_signal(value)¶
- set_observable_state_action_signal(value)¶
- set_observable_state_machine(value)¶
- set_observable_state_meta_signal(value)¶
- property sm_selection_changed_signal¶
- property state_action_signal¶
- property state_machine¶
- state_machine_model_after_change(model, prop_name, info)¶
- property state_meta_signal¶
- store_meta_data(copy_path=None)¶
Save meta data of the state machine model to the file system
This method generates a dictionary of the meta data of the state machine and stores it on the filesystem.
- Parameters:
copy_path (str) – Optional, if the path is specified, it will be used instead of the file system path
- suppress_new_root_state_model_one_time = False¶
- update_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
- update_meta_data_hash(obj_hash)¶
Should be implemented by derived classes to update the hash with their meta data fields
- Parameters:
obj_hash – The hash object (see Python hashlib)
ModificationsHistoryModel (in modification_history)¶
The History-Class provides the observation functionalities to register and identify all core or gui (graphical) edit actions that are a actual change to the state machine. Those changes are stored as Action-Objects in the ModificationsHistory-Class.
The HistoryChanges-Class provides the functionalities to organize and access all actions of the edit process. Hereby the branching of the edit process is stored and should be accessible, too.
- class rafcon.gui.models.modification_history.HistoryTreeElement(prev_id, action=None, next_id=None)¶
Bases:
object
- property history_id¶
- property next_id¶
- property old_next_ids¶
- prepare_destruction()¶
- property prev_id¶
- class rafcon.gui.models.modification_history.ModificationsHistory¶
Bases:
Observable
The Class holds a all time history and a trail history. The trail history holds directly all modifications made since the last reset until the actual last active change and the undone modifications of this branch of modifications. So the all time history holds a list of all modifications ordered by time whereby the list elements are TreeElements that know respective previous action’s list id and the possible next action list ids (multiple branches). Hereby a fast search from a actual active branch (trail history) to specific history_id (some branch) can be performed and all recovery steps collected. Additionally there will be implemented functionalities that never forget a single change that was insert for debugging reasons. - the pointer are pointing on the next undo … so redo is pointer + 1 - all_actions is a type of a tree # prev_id, action, next_id, old_next_ids
- property current_history_element¶
- get_current_branch_history_ids()¶
- get_element_for_history_id(history_id)¶
- get_executed_history_ids()¶
- get_history_path_from_current_to_target_history_id(target_history_id)¶
- get_next_element(for_history_element=None)¶
- get_previous_element(for_history_element=None)¶
- go_to_history_element(target_history_id)¶
- insert_action(**kwargs)¶
- is_redo_possible()¶
- is_undo_possible()¶
- prepare_destruction()¶
- redo(**kwargs)¶
- reset(**kwargs)¶
- undo(**kwargs)¶
- class rafcon.gui.models.modification_history.ModificationsHistoryModel(state_machine_model)¶
Bases:
ModelMT
- action_signal_after_complex_action(model, prop_name, info)¶
- property active_action¶
- after_count()¶
- assign_notification_root_state_after(model, prop_name, info)¶
This method is called, when any state, transition, data flow, etc. within the state machine modifications. This then typically requires a redraw of the graphical editor, to display these modifications immediately. :param model: The state machine model :param prop_name: The property that was changed :param info: Information about the change
- assign_notification_root_state_before(model, prop_name, info)¶
- assign_notification_states_after(model, prop_name, info)¶
This method is called, when any state, transition, data flow, etc. within the state machine modifications. This then typically requires a redraw of the graphical editor, to display these modifications immediately. :param model: The state machine model :param prop_name: The property that was changed :param info: Information about the change
- assign_notification_states_before(model, prop_name, info)¶
- before_count()¶
- property change_count¶
- finish_new_action(overview)¶
- get_observable_change_count()¶
- get_observable_modifications()¶
- get_root_state_element_meta()¶
- get_state_element_meta_from_internal_tmp_storage(state_path)¶
- meta_changed_notify_after(changed_model, prop_name, info)¶
- property modifications¶
- prepare_destruction()¶
Prepares the model for destruction
Un-registers itself as observer from the state machine and the root state
- re_initiate_meta_data()¶
- redo()¶
- reset_to_history_id(target_history_id)¶
Recovers a specific target_history_id of the _full_history element by doing several undos and redos.
- Parameters:
target_history_id – the id of the list element which is to recover
- Returns:
- set_observable_change_count(value)¶
- set_observable_modifications(value)¶
- start_new_action(overview)¶
- start_new_action_old(overview)¶
- state_action_signal(model, prop_name, info)¶
- state_machine_model = None¶
- synchronized_redo()¶
- synchronized_undo()¶
- property tmp_meta_storage¶
- undo()¶
- update_internal_tmp_storage()¶
AutoBackupModel (in auto_backup)¶
- class rafcon.gui.models.auto_backup.AutoBackupModel(state_machine_model)¶
Bases:
ModelMT
Class provides auto backup functionality for a state-machine.
The Class AutoBackupModel requests a threading.Lock object named storage_lock in the StateMachineModel handed to it to avoid inconsistencies if storing in the middle of a modification by API or e.g. ModificationHistory. The auto-backup class can be initiated but be disabled by TIMED_TEMPORARY_STORAGE_ENABLED in the gui_config.yaml. There are two mode to run this class – with fix interval checks for backup or by dynamical auto backup by setting the flag ONLY_FIX_FORCED_TEMPORARY_STORAGE_INTERVAL in the gui_config.yaml. The forced interval FORCED_TEMPORARY_STORAGE_INTERVAL is used for the fix auto backup interval and as the forced time interval for the dynamic auto backup. The dynamic auto backup will backup additionally if the user was not doing any modifications till a time horizon of TIMED_TEMPORARY_STORAGE_INTERVAL. The flag AUTO_RECOVERY_CHECK enables the check on not cleanly closed instances and state machines what only can be performed if the AUTO_RECOVERY_LOCK_ENABLED is set True to write respective lock files into the backup folders. If the lock file is not cleaned up the state machine and the RAFCON instance was not closed cleanly.
- cancel_timed_thread()¶
- change_in_state_machine_notification(model, prop_name, info)¶
- check_for_auto_backup(force=False)¶
The method implements the checks for possible auto backup of the state-machine according duration till the last change together with the private method _check_for_dyn_timed_auto_backup.
If the only_fix_interval is True this function is called ones in the beginning and is called by a timed- threads in a fix interval.
- Parameters:
force – is a flag that force the temporary backup of the state-machine to the tmp-folder
- Returns:
- check_lock_file()¶
- clean_lock_file(final=False)¶
- destroy()¶
- perform_temp_storage()¶
- prepare_destruction()¶
Prepares the model for destruction
Unregister itself as observer from the state machine and the root state
- set_timed_thread(duration, func, *args)¶
- update_last_backup_meta_data()¶
Update the auto backup meta data with internal recovery information
- update_last_sm_origin_meta_data()¶
Update the auto backup meta data with information of the state machine origin
- update_tmp_storage_path()¶
- write_backup_meta_data()¶
Write the auto backup meta data into the current tmp-storage path
- rafcon.gui.models.auto_backup.check_for_crashed_rafcon_instances()¶
- rafcon.gui.models.auto_backup.check_path_for_correct_dirty_lock_file(sm_path, path)¶
- rafcon.gui.models.auto_backup.find_dirty_lock_file_for_state_machine_path(sm_path)¶
- rafcon.gui.models.auto_backup.generate_rafcon_instance_lock_file()¶
- rafcon.gui.models.auto_backup.move_dirty_lock_file(dirty_lock_file, sm_path)¶
Move the dirt_lock file to the sm_path and thereby is not found by auto recovery of backup anymore
- rafcon.gui.models.auto_backup.recover_state_machine_from_backup(sm_path, pid=None, full_path_dirty_lock=None)¶
- rafcon.gui.models.auto_backup.remove_rafcon_instance_lock_file()¶