WIP: Use entity based api in replacement for object and relationship

spinetoolbox/fetch_parent.py

@@ -13,7 +13,8 @@
 The FetchParent and FlexibleFetchParent classes.
 """
 
-from PySide6.QtCore import QTimer, Signal, QObject
+from PySide6.QtCore import QTimer, Signal, QObject, Qt
+from PySide6.QtGui import QCursor
 from .helpers import busy_effect
 
 
@@ -55,7 +56,7 @@ def __init__(self, owner=None, chunk_size=1000):
             self._owner.destroyed.connect(lambda obj=None: self.set_obsolete(True))
         self.chunk_size = chunk_size
 
-    def reset_fetching(self, fetch_token):
+    def reset(self, fetch_token):
         """Resets fetch parent as if nothing was ever fetched.
 
         Args:
@@ -109,7 +110,7 @@ def remove_item(self, item, db_map):
 
     @property
     def fetch_item_type(self):
-        """Returns the type of item to fetch, e.g., "object_class".
+        """Returns the DB item type to fetch, e.g., "entity_class".
 
         Returns:
             str
@@ -160,6 +161,8 @@ def set_obsolete(self, obsolete):
         Args:
             obsolete (bool): whether parent has become obsolete
         """
+        if obsolete:
+            self.set_busy(False)
         self._obsolete = obsolete
 
     @property
@@ -172,6 +175,8 @@ def set_fetched(self, fetched):
         Args:
             fetched (bool): whether parent has been fetched completely
         """
+        if fetched:
+            self.set_busy(False)
         self._fetched = fetched
 
     @property
@@ -184,6 +189,10 @@ def set_busy(self, busy):
         Args:
             busy (bool): whether parent is busy fetching
         """
+        if busy:
+            qApp.setOverrideCursor(QCursor(Qt.BusyCursor))
+        else:
+            qApp.restoreOverrideCursor()
         self._busy = busy
 
     def handle_items_added(self, db_map_data):

spinetoolbox/helpers.py

@@ -32,7 +32,7 @@
 from PySide6.QtCore import Qt, Slot, QFile, QIODevice, QSize, QRect, QPoint, QUrl, QObject, QEvent
 from PySide6.QtCore import __version__ as qt_version
 from PySide6.QtCore import __version_info__ as qt_version_info
-from PySide6.QtWidgets import QApplication, QMessageBox, QFileIconProvider, QStyle, QFileDialog, QInputDialog
+from PySide6.QtWidgets import QApplication, QMessageBox, QFileIconProvider, QStyle, QFileDialog, QInputDialog, QSplitter
 from PySide6.QtGui import (
     QGuiApplication,
     QCursor,
@@ -54,6 +54,7 @@
 )
 from spine_engine.utils.serialization import deserialize_path
 from spinedb_api.spine_io.gdx_utils import find_gams_directory
+from spinedb_api.helpers import group_consecutive
 from .config import (
     DEFAULT_WORK_DIR,
     PLUGINS_PATH,
@@ -406,23 +407,15 @@ def format_string_list(str_list):
 
 
 def rows_to_row_count_tuples(rows):
-    """Breaks a list of rows into a list of (row, count) tuples to corresponding
-    chunks of successive rows.
+    """Breaks a list of rows into a list of (row, count) tuples corresponding to chunks of successive rows.
 
     Args:
         rows (Iterable of int): rows
 
     Returns:
         list of tuple: row count tuples
     """
-    rows = set(rows)
-    if not rows:
-        return []
-    sorted_rows = sorted(rows)
-    break_points = [k + 1 for k in range(len(sorted_rows) - 1) if sorted_rows[k] + 1 != sorted_rows[k + 1]]
-    break_points = [0] + break_points + [len(sorted_rows)]
-    ranges = [(break_points[l], break_points[l + 1]) for l in range(len(break_points) - 1)]
-    return [(sorted_rows[start], stop - start) for start, stop in ranges]
+    return [(first, last - first + 1) for first, last in group_consecutive(rows)]
 
 
 class IconListManager:
@@ -1393,6 +1386,9 @@ def restore_ui(window, app_settings, settings_group):
     window_state = app_settings.value("windowState")
     window_maximized = app_settings.value("windowMaximized", defaultValue='false')
     n_screens = app_settings.value("n_screens", defaultValue=1)
+    splitter_states = {
+        splitter: app_settings.value(splitter.objectName() + "State") for splitter in window.findChildren(QSplitter)
+    }
     app_settings.endGroup()
     original_size = window.size()
     if window_size:
@@ -1405,6 +1401,8 @@ def restore_ui(window, app_settings, settings_group):
     if len(QGuiApplication.screens()) < int(n_screens):
         # There are less screens available now than on previous application startup
         window.move(0, 0)  # Move this widget to primary screen position (0,0)
+    for splitter, state in splitter_states.items():
+        splitter.restoreState(state)
     ensure_window_is_on_screen(window, original_size)
     if window_maximized == 'true':
         window.setWindowState(Qt.WindowMaximized)
@@ -1424,6 +1422,8 @@ def save_ui(window, app_settings, settings_group):
     app_settings.setValue("windowState", window.saveState(version=1))
     app_settings.setValue("windowMaximized", window.windowState() == Qt.WindowMaximized)
     app_settings.setValue("n_screens", len(QGuiApplication.screens()))
+    for splitter in window.findChildren(QSplitter):
+        app_settings.setValue(splitter.objectName() + "State", splitter.saveState())
     app_settings.endGroup()
 
 
@@ -1549,31 +1549,6 @@ def _is_metadata_item(item):
     return "name" in item and "value" in item
 
 
-def separate_metadata_and_item_metadata(db_map_data):
-    """Separates normal metadata items from item metadata items.
-
-    Args:
-        db_map_data (dict): database records
-
-    Returns:
-        tuple: item metadata records and metadata records
-    """
-    metadata_db_map_data = {}
-    item_metadata_db_map_data = {}
-    for db_map, items in db_map_data.items():
-        metadata_items = []
-        entity_metadata_items = []
-        for item in items:
-            if _is_metadata_item(item):
-                metadata_items.append(item)
-            else:
-                entity_metadata_items.append(item)
-        if metadata_items:
-            metadata_db_map_data[db_map] = metadata_items
-        item_metadata_db_map_data[db_map] = entity_metadata_items
-    return item_metadata_db_map_data, metadata_db_map_data
-
-
 class HTMLTagFilter(HTMLParser):
     """HTML tag filter."""
 

spinetoolbox/mvcmodels/compound_table_model.py

@@ -385,9 +385,10 @@ def _get_row_for_insertion(self, pos):
 
     def _insert_row_map(self, pos, single_row_map):
         if not single_row_map:
-            # To trigger fetching. The QTimer is to avoid funny situations where the user enters new data
-            # via the empty row model, and those rows need to be removed at the same time as we fetch the added data.
-            # Doing it in the same loop cycle causes bugs.
+            # Emit layoutChanged to trigger fetching.
+            # The QTimer is to avoid funny situations where the user enters new data via the empty row model,
+            # and those rows need to be removed at the same time as we fetch the added data.
+            # Doing it in the same loop cycle was causing bugs.
             QTimer.singleShot(0, self.layoutChanged.emit)
             return
         row = self._get_row_for_insertion(pos)

spinetoolbox/mvcmodels/minimal_tree_model.py

@@ -160,7 +160,7 @@ def tear_down_recursively(self):
             child.tear_down_recursively()
         self.tear_down()
 
-    def remove_children(self, position, count):
+    def remove_children(self, position, count, tear_down=True):
         """Removes count children starting from the given position.
 
         Args:
@@ -182,8 +182,9 @@ def remove_children(self, position, count):
             child.parent_item = None
         del self.children[first : last + 1]
         self.model.endRemoveRows()
-        for child in children:
-            child.tear_down_recursively()
+        if tear_down:
+            for child in children:
+                child.tear_down_recursively()
         return True
 
     def clear_children(self):

spinetoolbox/mvcmodels/project_item_specification_models.py

@@ -107,13 +107,6 @@ def data(self, index, role=None):
         row = index.row()
         if role == Qt.ItemDataRole.DisplayRole:
             return self._spec_names[row]
-        if role == Qt.ItemDataRole.ToolTipRole:
-            if row >= self.rowCount():
-                return ""
-            return (
-                "<p>Drag-and-drop this onto the Design View "
-                f"to create a new <b>{self._spec_names[row]}</b> item.</p>"
-            )
         if role == Qt.ItemDataRole.DecorationRole:
             spec = self.specification(row)
             return self._icons[spec.item_type]

spinetoolbox/mvcmodels/resource_filter_model.py

@@ -15,14 +15,13 @@
 from PySide6.QtCore import Qt, Signal
 from PySide6.QtGui import QStandardItemModel, QStandardItem
 from spinedb_api.filters.scenario_filter import SCENARIO_FILTER_TYPE
-from spinedb_api.filters.tool_filter import TOOL_FILTER_TYPE
 from ..project_commands import SetFiltersOnlineCommand
 
 
 class ResourceFilterModel(QStandardItemModel):
     tree_built = Signal()
     _SELECT_ALL = "Select all"
-    _FILTER_TYPES = {"Scenario filter": SCENARIO_FILTER_TYPE, "Tool filter": TOOL_FILTER_TYPE}
+    _FILTER_TYPES = {"Scenario filter": SCENARIO_FILTER_TYPE}
     _FILTER_TYPE_TO_TEXT = dict(zip(_FILTER_TYPES.values(), _FILTER_TYPES.keys()))
 
     def __init__(self, connection, project, undo_stack, logger):
@@ -92,9 +91,6 @@ def fetch_filters(self):
             scenario_names = self._connection.get_scenario_names(url)
             if scenario_names:
                 filters.setdefault(resource.label, {})[SCENARIO_FILTER_TYPE] = scenario_names
-            tool_names = self._connection.get_tool_names(url)
-            if tool_names:
-                filters.setdefault(resource.label, {})[TOOL_FILTER_TYPE] = tool_names
         return filters
 
     def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
@@ -131,7 +127,7 @@ def set_online(self, resource, filter_type, online):
 
         Args:
             resource (str): Resource label
-            filter_type (str): Either SCENARIO_FILTER_TYPE or TOOL_FILTER_TYPE, for now.
+            filter_type (str): Always SCENARIO_FILTER_TYPE, for now.
             online (dict): mapping from scenario/tool id to online flag
         """
         self.connection.set_online(resource, filter_type, online)

spinetoolbox/project_item/logging_connection.py

@@ -11,7 +11,6 @@
 """Contains logging connection and jump classes."""
 
 from spinedb_api.filters.scenario_filter import SCENARIO_FILTER_TYPE
-from spinedb_api.filters.tool_filter import TOOL_FILTER_TYPE
 from spinedb_api import DatabaseMapping, SpineDBAPIError, SpineDBVersionError
 from spine_engine.project_item.connection import ResourceConvertingConnection, Jump, ConnectionBase, FilterSettings
 from ..log_mixin import LogMixin
@@ -80,15 +79,8 @@ def _convert_legacy_resource_filter_ids_to_filter_settings(self):
                     ).setdefault(SCENARIO_FILTER_TYPE, {})
                     for row in db_map.query(db_map.scenario_sq):
                         specific_filter_settings[row.name]: row.id = row.id in scenario_filter_ids
-                tool_filter_ids = resource_filter_ids.get(TOOL_FILTER_TYPE)
-                if tool_filter_ids is not None:
-                    specific_filter_settings = self._filter_settings.known_filters.setdefault(
-                        resource.label, {}
-                    ).setdefault(TOOL_FILTER_TYPE, {})
-                    for row in db_map.query(db_map.tool_sq):
-                        specific_filter_settings[row.name] = row.id in tool_filter_ids
             finally:
-                db_map.connection.close()
+                db_map.close()
         self._legacy_resource_filter_ids = None
 
     @staticmethod
@@ -157,7 +149,7 @@ def graphics_item(self):
         return self.link
 
     def has_filters(self):
-        """Returns True if connection has scenario or tool filters.
+        """Returns True if connection has scenario filters.
 
         Returns:
             bool: True if connection has filters, False otherwise
@@ -177,12 +169,6 @@ def has_filters(self):
                 return True
             if self._filter_settings.auto_online and any(name not in scenario_filters for name in available_scenarios):
                 return True
-            available_tools = {x["name"] for x in self._toolbox.db_mngr.get_items(db_map, "tool", only_visible=True)}
-            tool_filters = self._filter_settings.known_filters.get(resource.label, {}).get(TOOL_FILTER_TYPE, {})
-            if any(enabled for t, enabled in tool_filters.items() if t in available_tools):
-                return True
-            if self._filter_settings.auto_online and any(name not in tool_filters for name in available_tools):
-                return True
         return False
 
     def _get_db_map(self, url, ignore_version_error=False):
@@ -222,7 +208,7 @@ def _make_fetch_parent(self, db_map, item_type):
 
     def _fetch_more_if_possible(self):
         for db_map in self._db_maps.values():
-            for item_type in ("scenario", "tool"):
+            for item_type in ("scenario",):
                 fetch_parent = self._make_fetch_parent(db_map, item_type)
                 if self._toolbox.db_mngr.can_fetch_more(db_map, fetch_parent):
                     self._toolbox.db_mngr.fetch_more(db_map, fetch_parent)
@@ -247,12 +233,6 @@ def get_scenario_names(self, url):
             return []
         return sorted(x["name"] for x in self._toolbox.db_mngr.get_items(db_map, "scenario", only_visible=True))
 
-    def get_tool_names(self, url):
-        db_map = self._get_db_map(url)
-        if db_map is None:
-            return []
-        return sorted(x["name"] for x in self._toolbox.db_mngr.get_items(db_map, "tool", only_visible=True))
-
     def may_have_filters(self):
         """Returns whether this connection may have filters.
 
@@ -317,8 +297,8 @@ def set_online(self, resource, filter_type, online):
 
         Args:
             resource (str): Resource label
-            filter_type (str): Either SCENARIO_FILTER_TYPE or TOOL_FILTER_TYPE, for now.
-            online (dict): mapping from scenario/tool name to online flag
+            filter_type (str): Always SCENARIO_FILTER_TYPE, for now.
+            online (dict): mapping from scenario name to online flag
         """
         self._filter_settings.known_filters.setdefault(resource, {}).setdefault(filter_type, {}).update(online)
 
@@ -375,7 +355,7 @@ def _check_available_filters(self):
         """
         filter_settings = FilterSettings(auto_online=self._filter_settings.auto_online)
         for resource in self._resources:
-            for filter_type in (SCENARIO_FILTER_TYPE, TOOL_FILTER_TYPE):
+            for filter_type in (SCENARIO_FILTER_TYPE,):
                 online_filters = self._resource_filters_online(resource, filter_type)
                 if online_filters is not None:
                     filter_settings.known_filters.setdefault(resource.label, {})[filter_type] = online_filters
@@ -388,7 +368,7 @@ def _resource_filters_online(self, resource, filter_type):
         db_map = self._get_db_map(url)
         if db_map is None:
             return None
-        db_item_type = {SCENARIO_FILTER_TYPE: "scenario", TOOL_FILTER_TYPE: "tool"}[filter_type]
+        db_item_type = {SCENARIO_FILTER_TYPE: "scenario"}[filter_type]
         available_filters = (
             x["name"] for x in self._toolbox.db_mngr.get_items(db_map, db_item_type, only_visible=True)
         )

spinetoolbox/project_item/specification_editor_window.py

@@ -118,12 +118,11 @@ def _restore_dock_widgets(self):
         """Restores dockWidgets to some default state. Called in the constructor, before restoring the ui from settings.
         Reimplement in subclasses if needed."""
 
-    def _make_new_specification(self, spec_name, exiting=None):
+    def _make_new_specification(self, spec_name):
         """Returns a ProjectItemSpecification from current form settings.
 
         Args:
             spec_name (str): Name of the spec
-            exiting (bool, optional): Set as True if called when trying to exit the editor window
 
         Returns:
             ProjectItemSpecification
@@ -189,7 +188,7 @@ def _save(self, exiting=None):
                 return self.prompt_exit_without_saving()
             self.show_error("Please enter a name for the specification.")
             return False
-        spec = self._make_new_specification(name, exiting)
+        spec = self._make_new_specification(name)
         if spec is None:
             return self.prompt_exit_without_saving() if exiting else False
         if not self._original_spec_name: