Merge remote-tracking branch 'origin/develop' into feat/final_major_one_version

# Conflicts:
#	requirements.txt
#	setup.py
#	source/rafcon/core/start.py
#	source/rafcon/gui/start.py
#	source/rafcon/utils/profiling.py

Author: vahidm1993

CHANGELOG.rst

@@ -4,6 +4,16 @@ Changelog
 Information about :ref:`RAFCON` changes in each release will be published here. More
 details can be found in the `GIT commit log <https://github.com/DLR-RM/RAFCON/commits/develop>`__.
 
+Future Release
+"""""""
+- Features:
+    - Add skip & skip all buttons in the dialog of the broken libraries during loading a broken session
+    - Set the default directory of the dialog during saving a state machine in accordance with the chosen library in the library tree
+    - Create the data flows & data ports automatically in the nested states
+    - Create the data port automatically when the other state does not have one during connecting the data flows
+    - Support waypoints for data flows
+    - Custom background color for states
+
 
 1.0.0
 """""""

README.rst

@@ -96,7 +96,7 @@ via:
 
 .. code-block:: bash
 
-   pip install --user "pycairo<2.0.0,>=1.10.0"
+   pip install --user "pycairo==1.19.1"
 
 If you are using Python 3.4, you will need a ``pip`` version <= 8. Run the following command, to downgrade ``pip``:
 

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
 requires = [
-  "setuptools >= 40.9.0"
+  "setuptools==48.0.0"
 ]
 build-backend = "setuptools.build_meta"

share/rafcon/examples/libraries/turtle_libraries/clear_field/clear_field_CLEAR_FIELD/meta_data.json

@@ -1,15 +1,24 @@
 {
     "gui": {
         "editor_gaphas": {
+            "background_color": {
+                "__jsonqualname__": "__builtin__.tuple",
+                "items": [
+                    0.0,
+                    0.0,
+                    0.0
+                ]
+            },
+            "custom_background_color": false,
             "income": {
                 "rel_pos": {
-                    "__jsonqualname__": "__builtin__.tuple", 
+                    "__jsonqualname__": "__builtin__.tuple",
                     "items": [
-                        0, 
+                        0,
                         12.5
                     ]
                 }
-            }, 
+            },
             "name": {
                 "rel_pos": {
                     "__jsonqualname__": "__builtin__.tuple", 
@@ -42,6 +51,19 @@
             }
         }
     }, 
+    "income": {
+        "gui": {
+            "editor_gaphas": {
+                "rel_pos": {
+                    "__jsonqualname__": "__builtin__.tuple", 
+                    "items": [
+                        0, 
+                        12.5
+                    ]
+                }
+            }
+        }
+    }, 
     "outcome-1": {
         "gui": {
             "editor_gaphas": {

source/rafcon/core/config.py

@@ -36,7 +36,6 @@ class ObservableConfig(DefaultConfig, Observable):
 
     keys_requiring_state_machine_refresh = set()
     keys_requiring_restart = set()
-    keys_not_to_fill_up = set()
 
     def __init__(self, default_config_string, logger_object=None):
         DefaultConfig.__init__(self, default_config_string, logger_object, rel_config_path='rafcon')
@@ -90,7 +89,6 @@ class Config(ObservableConfig):
     """
 
     keys_requiring_restart = ()
-    keys_not_to_fill_up = {"LIBRARY_PATHS"}
 
     def __init__(self, logger_object=None):
         """Default constructor

source/rafcon/core/custom_exceptions.py

@@ -28,6 +28,19 @@ def __init__(self, message):
         super(LibraryNotFoundException, self).__init__(message)
 
 
+class LibraryNotFoundSkipException(Exception):
+
+    def __init__(self, message):
+        """ A custom exception for the case when a library is not found and user decided to skip loading the broken state machine
+
+        :param message: the error message for the exception
+        :return:
+        """
+
+        # Call the base class constructor with the parameters it needs
+        super(LibraryNotFoundSkipException, self).__init__(message)
+
+
 class RecoveryModeException(ValueError):
 
     def __init__(self, message, do_delete_item):

source/rafcon/core/decorators.py

@@ -23,6 +23,7 @@ def wraps_safely(obj, attr_names=functools.WRAPPER_ASSIGNMENTS):
     # Solves problem with missing attributes: http://stackoverflow.com/a/28752007
     return functools.wraps(obj, assigned=list(filter(functools.partial(hasattr, obj), attr_names)))
 
+
 global_lock_counter = 0
 
 

source/rafcon/core/execution/execution_engine.py

@@ -221,7 +221,6 @@ def _wait_for_finishing(self):
         self.__set_execution_mode_to_finished()
         self.state_machine_manager.active_state_machine_id = None
         plugins.run_on_state_machine_execution_finished()
-        # self.__set_execution_mode_to_stopped()
         self.state_machine_running = False
 
     def backward_step(self):
@@ -466,7 +465,6 @@ def handle_execution_mode(self, container_state, next_child_state_to_execute=Non
         """
         with self.state_counter_lock:
             self.state_counter += 1
-            # logger.verbose("Increase state_counter!" + str(self.state_counter))
 
         woke_up_from_pause_or_step_mode = False
 

source/rafcon/core/global_variable_manager.py

@@ -315,18 +315,6 @@ def get_all_keys_starting_with(self, start_key):
 # Properties for all class fields that must be observed by gtkmvc3
 #########################################################################
 
-    @property
-    def global_variable_dictionary(self):
-        """Property for the _global_variable_dictionary field"""
-        dict_copy = {}
-        for key, value in self.__global_variable_dictionary.items():
-            if key in self.__variable_references and self.__variable_references[key]:
-                dict_copy[key] = value
-            else:
-                dict_copy[key] = copy.deepcopy(value)
-
-        return dict_copy
-
     def get_all_keys(self):
         """Returns all variable names in the GVM
 
@@ -355,7 +343,6 @@ def check_value_and_type(value, data_type):
         :return:
         """
         if value is not None and data_type is not type(None):
-            # if not isinstance(value, data_type):
             if not type_inherits_of_type(data_type, type(value)):
                 raise TypeError(
                     "Value: '{0}' is not of data type: '{1}', value type: {2}".format(value, data_type, type(value)))

source/rafcon/core/id_generator.py

@@ -22,7 +22,6 @@
 import uuid
 
 STATE_ID_LENGTH = 6
-RUN_ID_LENGTH = 10
 experiment_id = ''+str(uuid.uuid1())
 
 state_name_counter = 0
@@ -34,7 +33,6 @@
 history_item_id_counter = 0
 semantic_data_id_counter = 0
 
-used_run_ids = []
 used_global_variable_ids = []
 
 

source/rafcon/core/interface.py

@@ -91,7 +91,7 @@ def save_folder_cmd_line(query, default_name=None, default_path=None):
     return user_input
 
 
-def show_notice(notice):
+def show_notice(notice, custom_buttons=None):
     """Shows a notice on the console that has to be acknowledged
 
     :param str notice: Notice to show to the user

source/rafcon/core/library_manager.py

@@ -27,12 +27,15 @@
 
 from rafcon.core import interface
 from rafcon.core.storage import storage
-from rafcon.core.custom_exceptions import LibraryNotFoundException
+from rafcon.core.custom_exceptions import LibraryNotFoundException, LibraryNotFoundSkipException
 import rafcon.core.config as config
 
 from rafcon.utils import log
 logger = log.get_logger(__name__)
 
+SKIP = 10
+SKIP_ALL = 11
+
 
 @Singleton
 class LibraryManager(Observable):
@@ -60,11 +63,9 @@ def __init__(self):
         # a list to hold all library states that were skipped by the user during the replacement procedure
         self._skipped_states = []
         self._skipped_library_roots = []
-
-        # loaded libraries
         self._loaded_libraries = {}
-        self._libraries_instances = {}
-
+        self._open_group_of_state_machines = False
+        self._skip_all_broken_libraries = False
         self._show_dialog = True
 
     @property
@@ -75,6 +76,22 @@ def show_dialog(self):
     def show_dialog(self, value):
         self._show_dialog = value
 
+    @property
+    def open_group_of_state_machines(self):
+        return self._open_group_of_state_machines
+
+    @open_group_of_state_machines.setter
+    def open_group_of_state_machines(self, value):
+        self._open_group_of_state_machines = value
+
+    @property
+    def skip_all_broken_libraries(self):
+        return self._skip_all_broken_libraries
+
+    @skip_all_broken_libraries.setter
+    def skip_all_broken_libraries(self, value):
+        self._skip_all_broken_libraries = value
+
     def prepare_destruction(self):
         self.clean_loaded_libraries()
 
@@ -178,7 +195,7 @@ def _load_nested_libraries(self, library_path, target_dict):
         :param target_dict: the target dictionary to store all loaded libraries to
         """
         for library_name in os.listdir(library_path):
-            library_folder_path, library_name = self.check_clean_path_of_library(library_path, library_name)
+            _, library_name = self.check_clean_path_of_library(library_path, library_name)
             full_library_path = os.path.join(library_path, library_name)
             if os.path.isdir(full_library_path) and library_name[0] != '.':
                 if os.path.exists(os.path.join(full_library_path, storage.STATEMACHINE_FILE)) \
@@ -271,7 +288,6 @@ def get_os_path_to_library(self, library_path, library_name, allow_user_interact
 
         library_os_path = self._get_library_os_path_from_library_dict_tree(library_path, library_name)
         while library_os_path is None:  # until the library is found or the user aborts
-
             regularly_found = False
             new_library_os_path = None
             if allow_user_interaction and self.show_dialog:
@@ -281,9 +297,16 @@ def get_os_path_to_library(self, library_path, library_name, allow_user_interact
                          "If your library_path is correct and the library was moved, please " \
                          "select the new root/library_os_path folder of the library which should be situated within a "\
                          "loaded library_root_path. If not, please abort.".format(library_name, library_path)
-                interface.show_notice_func(notice)
-                new_library_os_path = interface.open_folder_func("Select root folder for library name '{0}'"
-                                                                 "".format(original_path_and_name))
+                custom_buttons = (('Skip', SKIP), ('Skip All', SKIP_ALL)) if self.open_group_of_state_machines else None
+                response = SKIP if self.skip_all_broken_libraries else interface.show_notice_func(notice, custom_buttons)
+                if response == SKIP:
+                    raise LibraryNotFoundSkipException("Library '{0}' not found in sub-folder {1}".format(library_name, library_path))
+                elif response == SKIP_ALL:
+                    self.skip_all_broken_libraries = True
+                    raise LibraryNotFoundSkipException("Library '{0}' not found in sub-folder {1}".format(library_name, library_path))
+                else:
+                    new_library_os_path = interface.open_folder_func("Select root folder for library name '{0}'"
+                                                                     "".format(original_path_and_name))
             if new_library_os_path is None:
                 # User clicked cancel => cancel library search
                 # If the library root path is existent (e.g. "generic") and only the specific library state is not (
@@ -390,7 +413,7 @@ def get_library_state_copy_instance(self, lib_os_path):
         if lib_os_path in self._loaded_libraries:
             # this list can also be taken to open library state machines TODO -> implement it -> because faster
             state_machine = self._loaded_libraries[lib_os_path]
-            # as long as the a library state root state is never edited so the state first has to be copied here
+            # as long as the library state root state is never edited so the state first has to be copied here
             state_copy = copy.deepcopy(state_machine.root_state)
             return state_machine.version, state_copy
         else:

source/rafcon/core/state_elements/scope.py

@@ -37,15 +37,6 @@ def generate_time_stamp():
     return int(round(time.time() * 1000000))
 
 
-def get_human_readable_time(timestamp):
-    """
-    Converts a timestamp to a human readable format.
-    :param timestamp: the timestamp to be converted
-    :return: the converted timestamp
-    """
-    return datetime.datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
-
-
 class ScopedVariable(DataPort):
     """A class for representing a scoped variable in a container state
 

source/rafcon/core/state_elements/state_element.py

@@ -61,8 +61,6 @@ def __deepcopy__(self, memo=None, _nil=[]):
         raise NotImplementedError("__deepcopy__ method of class StateElement has to be implemented")
 
     def _safe_init(self, parent):
-        # uncomment this line when using LOAD_SM_WITH_CHECKS to check if unsafe_init triggers safe_init
-        # raise Exception("Must not be executed during unsafe init")
         self.parent = parent
 
     def _unsafe_init(self, parent):

source/rafcon/core/state_machine.py

@@ -54,8 +54,6 @@ class StateMachine(Observable, JSONObject, Hashable):
     state_machine_id = None
     version = None
 
-    old_marked_dirty = True
-
     _root_state = None
     _marked_dirty = True
     _file_system_path = None
@@ -189,8 +187,6 @@ def root_state(self):
     @root_state.setter
     @Observable.observed
     def root_state(self, root_state):
-        # if not isinstance(root_state, State):
-        #     raise AttributeError("root_state has to be of type State")
         if root_state is not None:
             from rafcon.core.states.state import State
             if not isinstance(root_state, State):
@@ -241,7 +237,6 @@ def marked_dirty(self):
     def marked_dirty(self, marked_dirty):
         if not isinstance(marked_dirty, bool):
             raise AttributeError("marked_dirty has to be of type bool")
-        self.old_marked_dirty = self._marked_dirty
         self._marked_dirty = marked_dirty
 
     def get_state_by_path(self, path, as_check=False):

source/rafcon/core/state_machine_manager.py

@@ -79,11 +79,6 @@ def has_dirty_state_machine(self):
                 return True
         return False
 
-    def reset_dirty_flags(self):
-        """Set all marked_dirty flags of the state machine to false."""
-        for sm_id, sm in self.state_machines.items():
-            sm.marked_dirty = False
-
     def is_state_machine_open(self, file_system_path):
         for loaded_sm in self._state_machines.values():
             if loaded_sm.file_system_path == file_system_path:

source/rafcon/core/states/concurrency_state.py

@@ -99,20 +99,20 @@ def start_child_states(self, concurrency_history_item, do_not_start_state=None):
                 state.concurrency_queue_id = index
 
                 state.generate_run_id()
-                target_excution_history = None
+                target_execution_history = None
                 if not self.backward_execution:
                     # In the case that execution logging is disabled there is no concurrency_history_item
                     if concurrency_history_item:
                         # care for the history items; this item is only for execution visualization
                         concurrency_history_item.execution_histories[index].push_call_history_item(
                             state, CallType.EXECUTE, self, state.input_data)
-                        target_excution_history = concurrency_history_item.execution_histories[index]
+                        target_execution_history = concurrency_history_item.execution_histories[index]
                 else:  # backward execution
                     last_history_item = concurrency_history_item.execution_histories[index].pop_last_item()
                     assert isinstance(last_history_item, ReturnItem)
-                    target_excution_history = concurrency_history_item.execution_histories[index]
+                    target_execution_history = concurrency_history_item.execution_histories[index]
 
-                state.start(target_excution_history, self.backward_execution, False)
+                state.start(target_execution_history, self.backward_execution, False)
 
         return concurrency_queue