diff --git a/client/ayon_core/tools/sceneinventory/control.py b/client/ayon_core/tools/sceneinventory/control.py index 592113455c..c564b5a992 100644 --- a/client/ayon_core/tools/sceneinventory/control.py +++ b/client/ayon_core/tools/sceneinventory/control.py @@ -1,14 +1,14 @@ import ayon_api from ayon_core.lib.events import QueuedEventSystem -from ayon_core.host import ILoadHost +from ayon_core.host import HostBase, ILoadHost from ayon_core.pipeline import ( registered_host, get_current_context, ) from ayon_core.tools.common_models import HierarchyModel -from .models import SiteSyncModel +from .models import SiteSyncModel, ContainersModel class SceneInventoryController: @@ -28,11 +28,15 @@ class SceneInventoryController: self._current_folder_id = None self._current_folder_set = False + self._containers_model = ContainersModel(self) self._sitesync_model = SiteSyncModel(self) # Switch dialog requirements self._hierarchy_model = HierarchyModel(self) self._event_system = self._create_event_system() + def get_host(self) -> HostBase: + return self._host + def emit_event(self, topic, data=None, source=None): if data is None: data = {} @@ -47,6 +51,7 @@ class SceneInventoryController: self._current_folder_id = None self._current_folder_set = False + self._containers_model.reset() self._sitesync_model.reset() self._hierarchy_model.reset() @@ -80,13 +85,26 @@ class SceneInventoryController: self._current_folder_set = True return self._current_folder_id + # Containers methods def get_containers(self): - host = self._host - if isinstance(host, ILoadHost): - return list(host.get_containers()) - elif hasattr(host, "ls"): - return list(host.ls()) - return [] + return self._containers_model.get_containers() + + def get_containers_by_item_ids(self, item_ids): + return self._containers_model.get_containers_by_item_ids(item_ids) + + def get_container_items(self): + return self._containers_model.get_container_items() + + def get_container_items_by_id(self, item_ids): + return self._containers_model.get_container_items_by_id(item_ids) + + def get_representation_info_items(self, representation_ids): + return self._containers_model.get_representation_info_items( + representation_ids + ) + + def get_version_items(self, product_ids): + return self._containers_model.get_version_items(product_ids) # Site Sync methods def is_sitesync_enabled(self): diff --git a/client/ayon_core/tools/sceneinventory/delegates.py b/client/ayon_core/tools/sceneinventory/delegates.py index 2126fa1cbe..6f91587613 100644 --- a/client/ayon_core/tools/sceneinventory/delegates.py +++ b/client/ayon_core/tools/sceneinventory/delegates.py @@ -1,38 +1,10 @@ -import numbers - -import ayon_api - -from ayon_core.pipeline import HeroVersionType -from ayon_core.tools.utils.models import TreeModel -from ayon_core.tools.utils.lib import format_version - from qtpy import QtWidgets, QtCore, QtGui +from .model import VERSION_LABEL_ROLE + class VersionDelegate(QtWidgets.QStyledItemDelegate): """A delegate that display version integer formatted as version string.""" - - version_changed = QtCore.Signal() - first_run = False - lock = False - - def __init__(self, controller, *args, **kwargs): - self._controller = controller - super(VersionDelegate, self).__init__(*args, **kwargs) - - def get_project_name(self): - return self._controller.get_current_project_name() - - def displayText(self, value, locale): - if isinstance(value, HeroVersionType): - return format_version(value) - if not isinstance(value, numbers.Integral): - # For cases where no version is resolved like NOT FOUND cases - # where a representation might not exist in current database - return - - return format_version(value) - def paint(self, painter, option, index): fg_color = index.data(QtCore.Qt.ForegroundRole) if fg_color: @@ -44,7 +16,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate): fg_color = None if not fg_color: - return super(VersionDelegate, self).paint(painter, option, index) + return super().paint(painter, option, index) if option.widget: style = option.widget.style() @@ -60,9 +32,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate): painter.save() - text = self.displayText( - index.data(QtCore.Qt.DisplayRole), option.locale - ) + text = index.data(VERSION_LABEL_ROLE) pen = painter.pen() pen.setColor(fg_color) painter.setPen(pen) @@ -82,77 +52,3 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate): ) painter.restore() - - def createEditor(self, parent, option, index): - item = index.data(TreeModel.ItemRole) - if item.get("isGroup") or item.get("isMerged"): - return - - editor = QtWidgets.QComboBox(parent) - - def commit_data(): - if not self.first_run: - self.commitData.emit(editor) # Update model data - self.version_changed.emit() # Display model data - editor.currentIndexChanged.connect(commit_data) - - self.first_run = True - self.lock = False - - return editor - - def setEditorData(self, editor, index): - if self.lock: - # Only set editor data once per delegation - return - - editor.clear() - - # Current value of the index - item = index.data(TreeModel.ItemRole) - value = index.data(QtCore.Qt.DisplayRole) - - project_name = self.get_project_name() - # Add all available versions to the editor - product_id = item["version_entity"]["productId"] - version_entities = list(sorted( - ayon_api.get_versions( - project_name, product_ids={product_id}, active=True - ), - key=lambda item: abs(item["version"]) - )) - - selected = None - items = [] - is_hero_version = value < 0 - for version_entity in version_entities: - version = version_entity["version"] - label = format_version(version) - item = QtGui.QStandardItem(label) - item.setData(version_entity, QtCore.Qt.UserRole) - items.append(item) - - if ( - version == value - or is_hero_version and version < 0 - ): - selected = item - - # Reverse items so latest versions be upper - items.reverse() - for item in items: - editor.model().appendRow(item) - - index = 0 - if selected: - index = selected.row() - - # Will trigger index-change signal - editor.setCurrentIndex(index) - self.first_run = False - self.lock = True - - def setModelData(self, editor, model, index): - """Apply the integer version back in the model""" - version = editor.itemData(editor.currentIndex()) - model.setData(index, version["name"]) diff --git a/client/ayon_core/tools/sceneinventory/model.py b/client/ayon_core/tools/sceneinventory/model.py index 330b174218..052bdf3e4e 100644 --- a/client/ayon_core/tools/sceneinventory/model.py +++ b/client/ayon_core/tools/sceneinventory/model.py @@ -1,57 +1,110 @@ import re import logging -import uuid -from collections import defaultdict +import collections -import ayon_api from qtpy import QtCore, QtGui import qtawesome from ayon_core.pipeline import ( - get_current_project_name, HeroVersionType, ) from ayon_core.style import get_default_entity_icon_color from ayon_core.tools.utils import get_qt_icon -from ayon_core.tools.utils.models import TreeModel, Item +from ayon_core.tools.utils.lib import format_version + +ITEM_ID_ROLE = QtCore.Qt.UserRole + 1 +NAME_COLOR_ROLE = QtCore.Qt.UserRole + 2 +COUNT_ROLE = QtCore.Qt.UserRole + 3 +IS_CONTAINER_ITEM_ROLE = QtCore.Qt.UserRole + 4 +VERSION_IS_LATEST_ROLE = QtCore.Qt.UserRole + 5 +VERSION_VALUE_ROLE = QtCore.Qt.UserRole + 6 +VERSION_LABEL_ROLE = QtCore.Qt.UserRole + 7 +VERSION_COLOR_ROLE = QtCore.Qt.UserRole + 8 +STATUS_NAME_ROLE = QtCore.Qt.UserRole + 9 +STATUS_COLOR_ROLE = QtCore.Qt.UserRole + 10 +PRODUCT_ID_ROLE = QtCore.Qt.UserRole + 11 +PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 12 +PRODUCT_TYPE_ICON_ROLE = QtCore.Qt.UserRole + 13 +PRODUCT_GROUP_NAME_ROLE = QtCore.Qt.UserRole + 14 +PRODUCT_GROUP_ICON_ROLE = QtCore.Qt.UserRole + 15 +LOADER_NAME_ROLE = QtCore.Qt.UserRole + 16 +OBJECT_NAME_ROLE = QtCore.Qt.UserRole + 17 +ACTIVE_SITE_PROGRESS_ROLE = QtCore.Qt.UserRole + 18 +REMOTE_SITE_PROGRESS_ROLE = QtCore.Qt.UserRole + 19 +ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 20 +REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 21 +# This value hold unique value of container that should be used to identify +# containers inbetween refresh. +ITEM_UNIQUE_NAME_ROLE = QtCore.Qt.UserRole + 22 -def walk_hierarchy(node): - """Recursively yield group node.""" - for child in node.children(): - if child.get("isGroupNode"): - yield child - - for _child in walk_hierarchy(child): - yield _child - - -class InventoryModel(TreeModel): +class InventoryModel(QtGui.QStandardItemModel): """The model for the inventory""" - Columns = [ + column_labels = [ "Name", - "version", - "count", - "productType", - "group", - "loader", - "objectName", - "active_site", - "remote_site", + "Version", + "Count", + "Product type", + "Group", + "Loader", + "Object name", + "Active site", + "Remote site", ] - active_site_col = Columns.index("active_site") - remote_site_col = Columns.index("remote_site") + name_col = column_labels.index("Name") + version_col = column_labels.index("Version") + count_col = column_labels.index("Count") + product_type_col = column_labels.index("Product type") + product_group_col = column_labels.index("Group") + loader_col = column_labels.index("Loader") + object_name_col = column_labels.index("Object name") + active_site_col = column_labels.index("Active site") + remote_site_col = column_labels.index("Remote site") + display_role_by_column = { + name_col: QtCore.Qt.DisplayRole, + version_col: VERSION_LABEL_ROLE, + count_col: COUNT_ROLE, + # 3: STATUS_NAME_ROLE, + product_type_col: PRODUCT_TYPE_ROLE, + product_group_col: PRODUCT_GROUP_NAME_ROLE, + loader_col: LOADER_NAME_ROLE, + object_name_col: OBJECT_NAME_ROLE, + active_site_col: ACTIVE_SITE_PROGRESS_ROLE, + remote_site_col: REMOTE_SITE_PROGRESS_ROLE, + } + decoration_role_by_column = { + name_col: QtCore.Qt.DecorationRole, + product_type_col: PRODUCT_TYPE_ICON_ROLE, + product_group_col: PRODUCT_GROUP_ICON_ROLE, + active_site_col: ACTIVE_SITE_ICON_ROLE, + remote_site_col: REMOTE_SITE_ICON_ROLE, + } + foreground_role_by_column = { + version_col: VERSION_COLOR_ROLE, + name_col: NAME_COLOR_ROLE, + } + width_by_column = { + name_col: 250, + version_col: 55, + count_col: 55, + product_type_col: 150, + product_group_col: 120, + loader_col: 150, + } OUTDATED_COLOR = QtGui.QColor(235, 30, 30) CHILD_OUTDATED_COLOR = QtGui.QColor(200, 160, 30) GRAYOUT_COLOR = QtGui.QColor(160, 160, 160) - UniqueRole = QtCore.Qt.UserRole + 2 # unique label role - def __init__(self, controller, parent=None): - super(InventoryModel, self).__init__(parent) + super().__init__(parent) + + self.setColumnCount(len(self.column_labels)) + for idx, label in enumerate(self.column_labels): + self.setHeaderData(idx, QtCore.Qt.Horizontal, label) + self.log = logging.getLogger(self.__class__.__name__) self._controller = controller @@ -60,103 +113,201 @@ class InventoryModel(TreeModel): self._default_icon_color = get_default_entity_icon_color() - site_icons = self._controller.get_site_provider_icons() - - self._site_icons = { - provider: get_qt_icon(icon_def) - for provider, icon_def in site_icons.items() - } - def outdated(self, item): return item.get("isOutdated", True) + def refresh(self, selected=None): + """Refresh the model""" + # for debugging or testing, injecting items from outside + container_items = self._controller.get_container_items() + + self._clear_items() + + items_by_repre_id = {} + for container_item in container_items: + # if ( + # selected is not None + # and container_item.item_id not in selected + # ): + # continue + repre_id = container_item.representation_id + items = items_by_repre_id.setdefault(repre_id, []) + items.append(container_item) + + repre_id = set(items_by_repre_id.keys()) + repre_info_by_id = self._controller.get_representation_info_items( + repre_id + ) + product_ids = { + repre_info.product_id + for repre_info in repre_info_by_id.values() + } + version_items_by_product_id = self._controller.get_version_items( + product_ids + ) + # SiteSync addon information + progress_by_id = self._controller.get_representations_site_progress( + repre_id + ) + sites_info = self._controller.get_sites_information() + site_icons = { + provider: get_qt_icon(icon_def) + for provider, icon_def in ( + self._controller.get_site_provider_icons().items() + ) + } + + group_item_icon = qtawesome.icon( + "fa.folder", color=self._default_icon_color + ) + valid_item_icon = qtawesome.icon( + "fa.file-o", color=self._default_icon_color + ) + invalid_item_icon = qtawesome.icon( + "fa.exclamation-circle", color=self._default_icon_color + ) + group_icon = qtawesome.icon( + "fa.object-group", color=self._default_icon_color + ) + product_type_icon = qtawesome.icon( + "fa.folder", color="#0091B2" + ) + group_item_font = QtGui.QFont() + group_item_font.setBold(True) + + active_site_icon = site_icons.get(sites_info["active_site_provider"]) + remote_site_icon = site_icons.get(sites_info["remote_site_provider"]) + + root_item = self.invisibleRootItem() + + group_items = [] + for repre_id, container_items in items_by_repre_id.items(): + repre_info = repre_info_by_id[repre_id] + version_label = "N/A" + version_color = None + version_value = None + is_latest = False + if not repre_info.is_valid: + group_name = "< Entity N/A >" + item_icon = invalid_item_icon + + else: + group_name = "{}_{}: ({})".format( + repre_info.folder_path.rsplit("/")[-1], + repre_info.product_name, + repre_info.representation_name + ) + item_icon = valid_item_icon + + version_items = ( + version_items_by_product_id[repre_info.product_id] + ) + version_item = version_items[repre_info.version_id] + version_value = version_item.version + if version_value < 0: + version_value = HeroVersionType(version_value) + version_label = format_version(version_value) + is_latest = version_item.is_latest + if not is_latest: + version_color = self.OUTDATED_COLOR + + container_model_items = [] + for container_item in container_items: + unique_name = ( + repre_info.representation_name + + container_item.object_name or "" + ) + + item = QtGui.QStandardItem() + item.setColumnCount(root_item.columnCount()) + item.setData(container_item.namespace, QtCore.Qt.DisplayRole) + item.setData(self.GRAYOUT_COLOR, NAME_COLOR_ROLE) + item.setData(self.GRAYOUT_COLOR, VERSION_COLOR_ROLE) + item.setData(item_icon, QtCore.Qt.DecorationRole) + item.setData(repre_info.product_id, PRODUCT_ID_ROLE) + item.setData(container_item.item_id, ITEM_ID_ROLE) + item.setData(version_value, VERSION_VALUE_ROLE) + item.setData(version_label, VERSION_LABEL_ROLE) + item.setData(True, IS_CONTAINER_ITEM_ROLE) + item.setData(unique_name, ITEM_UNIQUE_NAME_ROLE) + container_model_items.append(item) + + if not container_model_items: + continue + + progress = progress_by_id[repre_id] + active_site_progress = "{}%".format( + max(progress["active_site"], 0) * 100 + ) + remote_site_progress = "{}%".format( + max(progress["remote_site"], 0) * 100 + ) + + group_item = QtGui.QStandardItem() + group_item.setColumnCount(root_item.columnCount()) + group_item.setData(group_name, QtCore.Qt.DisplayRole) + group_item.setData(group_name, ITEM_UNIQUE_NAME_ROLE) + group_item.setData(group_item_icon, QtCore.Qt.DecorationRole) + group_item.setData(group_item_font, QtCore.Qt.FontRole) + group_item.setData(repre_info.product_id, PRODUCT_ID_ROLE) + group_item.setData(repre_info.product_type, PRODUCT_TYPE_ROLE) + group_item.setData(product_type_icon, PRODUCT_TYPE_ICON_ROLE) + group_item.setData(is_latest, VERSION_IS_LATEST_ROLE) + group_item.setData(version_label, VERSION_LABEL_ROLE) + group_item.setData(len(container_items), COUNT_ROLE) + group_item.setData( + active_site_progress, ACTIVE_SITE_PROGRESS_ROLE + ) + group_item.setData( + remote_site_progress, REMOTE_SITE_PROGRESS_ROLE + ) + group_item.setData(active_site_icon, ACTIVE_SITE_ICON_ROLE) + group_item.setData(remote_site_icon, REMOTE_SITE_ICON_ROLE) + group_item.setData(False, IS_CONTAINER_ITEM_ROLE) + + if version_color is not None: + group_item.setData(version_color, VERSION_COLOR_ROLE) + + if repre_info.product_group: + group_item.setData( + repre_info.product_group, PRODUCT_GROUP_NAME_ROLE + ) + group_item.setData(group_icon, PRODUCT_GROUP_ICON_ROLE) + + group_item.appendRows(container_model_items) + group_items.append(group_item) + + if group_items: + root_item.appendRows(group_items) + + def flags(self, index): + return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable + def data(self, index, role): if not index.isValid(): return - item = index.internalPointer() + col = index.column() + if role == QtCore.Qt.DisplayRole: + role = self.display_role_by_column.get(col) + if role is None: + print(col, role) + return None - if role == QtCore.Qt.FontRole: - # Make top-level entries bold - if item.get("isGroupNode") or item.get("isNotSet"): # group-item - font = QtGui.QFont() - font.setBold(True) - return font + elif role == QtCore.Qt.DecorationRole: + role = self.decoration_role_by_column.get(col) + if role is None: + return None - if role == QtCore.Qt.ForegroundRole: - # Set the text color to the OUTDATED_COLOR when the - # collected version is not the same as the highest version - key = self.Columns[index.column()] - if key == "version": # version - if item.get("isGroupNode"): # group-item - if self.outdated(item): - return self.OUTDATED_COLOR + elif role == QtCore.Qt.ForegroundRole: + role = self.foreground_role_by_column.get(col) + if role is None: + return None - if self._hierarchy_view: - # If current group is not outdated, check if any - # outdated children. - for _node in walk_hierarchy(item): - if self.outdated(_node): - return self.CHILD_OUTDATED_COLOR - else: + if col != 0: + index = self.index(index.row(), 0, index.parent()) - if self._hierarchy_view: - # Although this is not a group item, we still need - # to distinguish which one contain outdated child. - for _node in walk_hierarchy(item): - if self.outdated(_node): - return self.CHILD_OUTDATED_COLOR.darker(150) - - return self.GRAYOUT_COLOR - - if key == "Name" and not item.get("isGroupNode"): - return self.GRAYOUT_COLOR - - # Add icons - if role == QtCore.Qt.DecorationRole: - if index.column() == 0: - # Override color - color = item.get("color", self._default_icon_color) - if item.get("isGroupNode"): # group-item - return qtawesome.icon("fa.folder", color=color) - if item.get("isNotSet"): - return qtawesome.icon("fa.exclamation-circle", color=color) - - return qtawesome.icon("fa.file-o", color=color) - - if index.column() == 3: - # Product type icon - return item.get("productTypeIcon", None) - - column_name = self.Columns[index.column()] - - if column_name == "group" and item.get("group"): - return qtawesome.icon("fa.object-group", - color=get_default_entity_icon_color()) - - if item.get("isGroupNode"): - if column_name == "active_site": - provider = item.get("active_site_provider") - return self._site_icons.get(provider) - - if column_name == "remote_site": - provider = item.get("remote_site_provider") - return self._site_icons.get(provider) - - if role == QtCore.Qt.DisplayRole and item.get("isGroupNode"): - column_name = self.Columns[index.column()] - progress = None - if column_name == "active_site": - progress = item.get("active_site_progress", 0) - elif column_name == "remote_site": - progress = item.get("remote_site_progress", 0) - if progress is not None: - return "{}%".format(max(progress, 0) * 100) - - if role == self.UniqueRole: - return item["representation"] + item.get("objectName", "") - - return super(InventoryModel, self).data(index, role) + return super().data(index, role) def set_hierarchy_view(self, state): """Set whether to display products in hierarchy view.""" @@ -165,299 +316,21 @@ class InventoryModel(TreeModel): if state != self._hierarchy_view: self._hierarchy_view = state - def refresh(self, selected=None, containers=None): - """Refresh the model""" + def get_outdated_item_ids(self): + return set() - # for debugging or testing, injecting items from outside - if containers is None: - containers = self._controller.get_containers() - - self.clear() - if not selected or not self._hierarchy_view: - self._add_containers(containers) - return - - # Filter by cherry-picked items - self._add_containers(( - container - for container in containers - if container["objectName"] in selected - )) - - def _add_containers(self, containers, parent=None): - """Add the items to the model. - - The items should be formatted similar to `api.ls()` returns, an item - is then represented as: - {"filename_v001.ma": [full/filename/of/loaded/filename_v001.ma, - full/filename/of/loaded/filename_v001.ma], - "nodetype" : "reference", - "node": "referenceNode1"} - - Note: When performing an additional call to `add_items` it will *not* - group the new items with previously existing item groups of the - same type. - - Args: - containers (generator): Container items. - parent (Item, optional): Set this item as parent for the added - items when provided. Defaults to the root of the model. - - Returns: - node.Item: root node which has children added based on the data - """ - - project_name = get_current_project_name() - - self.beginResetModel() - - # Group by representation - grouped = defaultdict(lambda: {"containers": list()}) - for container in containers: - repre_id = container["representation"] - grouped[repre_id]["containers"].append(container) - - ( - repres_by_id, - versions_by_id, - products_by_id, - folders_by_id, - ) = self._query_entities(project_name, set(grouped.keys())) - # Add to model - not_found = defaultdict(list) - not_found_ids = [] - for repre_id, group_dict in sorted(grouped.items()): - group_containers = group_dict["containers"] - representation = repres_by_id.get(repre_id) - if not representation: - not_found["representation"].extend(group_containers) - not_found_ids.append(repre_id) - continue - - version_entity = versions_by_id.get(representation["versionId"]) - if not version_entity: - not_found["version"].extend(group_containers) - not_found_ids.append(repre_id) - continue - - product_entity = products_by_id.get(version_entity["productId"]) - if not product_entity: - not_found["product"].extend(group_containers) - not_found_ids.append(repre_id) - continue - - folder_entity = folders_by_id.get(product_entity["folderId"]) - if not folder_entity: - not_found["folder"].extend(group_containers) - not_found_ids.append(repre_id) - continue - - group_dict.update({ - "representation": representation, - "version": version_entity, - "product": product_entity, - "folder": folder_entity - }) - - for _repre_id in not_found_ids: - grouped.pop(_repre_id) - - for where, group_containers in not_found.items(): - # create the group header - group_node = Item() - name = "< NOT FOUND - {} >".format(where) - group_node["Name"] = name - group_node["representation"] = name - group_node["count"] = len(group_containers) - group_node["isGroupNode"] = False - group_node["isNotSet"] = True - - self.add_child(group_node, parent=parent) - - for container in group_containers: - item_node = Item() - item_node.update(container) - item_node["Name"] = container.get("objectName", "NO NAME") - item_node["isNotFound"] = True - self.add_child(item_node, parent=group_node) - - # TODO Use product icons - product_type_icon = qtawesome.icon( - "fa.folder", color="#0091B2" - ) - # Prepare site sync specific data - progress_by_id = self._controller.get_representations_site_progress( - set(grouped.keys()) - ) - sites_info = self._controller.get_sites_information() - - # Query the highest available version so the model can know - # whether current version is currently up-to-date. - highest_version_by_product_id = ayon_api.get_last_versions( - project_name, - product_ids={ - group["version"]["productId"] for group in grouped.values() - }, - fields={"productId", "version"} - ) - # Map value to `version` key - highest_version_by_product_id = { - product_id: version["version"] - for product_id, version in highest_version_by_product_id.items() - } - - for repre_id, group_dict in sorted(grouped.items()): - group_containers = group_dict["containers"] - repre_entity = group_dict["representation"] - version_entity = group_dict["version"] - folder_entity = group_dict["folder"] - product_entity = group_dict["product"] - - product_type = product_entity["productType"] - - # create the group header - group_node = Item() - group_node["Name"] = "{}_{}: ({})".format( - folder_entity["name"], - product_entity["name"], - repre_entity["name"] - ) - group_node["representation"] = repre_id - - # Detect hero version type - version = version_entity["version"] - if version < 0: - version = HeroVersionType(version) - group_node["version"] = version - - # Check if the version is outdated. - # Hero versions are never considered to be outdated. - is_outdated = False - if not isinstance(version, HeroVersionType): - last_version = highest_version_by_product_id.get( - version_entity["productId"]) - if last_version is not None: - is_outdated = version_entity["version"] != last_version - group_node["isOutdated"] = is_outdated - - group_node["productType"] = product_type or "" - group_node["productTypeIcon"] = product_type_icon - group_node["count"] = len(group_containers) - group_node["isGroupNode"] = True - group_node["group"] = product_entity["attrib"].get("productGroup") - - # Site sync specific data - progress = progress_by_id[repre_id] - group_node.update(sites_info) - group_node["active_site_progress"] = progress["active_site"] - group_node["remote_site_progress"] = progress["remote_site"] - - self.add_child(group_node, parent=parent) - - for container in group_containers: - item_node = Item() - item_node.update(container) - - # store the current version on the item - item_node["version"] = version_entity["version"] - item_node["version_entity"] = version_entity - - # Remapping namespace to item name. - # Noted that the name key is capital "N", by doing this, we - # can view namespace in GUI without changing container data. - item_node["Name"] = container["namespace"] - - self.add_child(item_node, parent=group_node) - - self.endResetModel() - - return self._root_item - - def _query_entities(self, project_name, repre_ids): - """Query entities for representations from containers. - - Returns: - tuple[dict, dict, dict, dict]: Representation, version, product - and folder documents by id. - """ - - repres_by_id = {} - versions_by_id = {} - products_by_id = {} - folders_by_id = {} - output = ( - repres_by_id, - versions_by_id, - products_by_id, - folders_by_id, - ) - - filtered_repre_ids = set() - for repre_id in repre_ids: - # Filter out invalid representation ids - # NOTE: This is added because scenes from OpenPype did contain - # ObjectId from mongo. - try: - uuid.UUID(repre_id) - filtered_repre_ids.add(repre_id) - except ValueError: - continue - if not filtered_repre_ids: - return output - - repre_entities = ayon_api.get_representations(project_name, repre_ids) - repres_by_id.update({ - repre_entity["id"]: repre_entity - for repre_entity in repre_entities - }) - version_ids = { - repre_entity["versionId"] - for repre_entity in repres_by_id.values() - } - if not version_ids: - return output - - versions_by_id.update({ - version_entity["id"]: version_entity - for version_entity in ayon_api.get_versions( - project_name, version_ids=version_ids - ) - }) - - product_ids = { - version_entity["productId"] - for version_entity in versions_by_id.values() - } - if not product_ids: - return output - - products_by_id.update({ - product_entity["id"]: product_entity - for product_entity in ayon_api.get_products( - project_name, product_ids=product_ids - ) - }) - folder_ids = { - product_entity["folderId"] - for product_entity in products_by_id.values() - } - if not folder_ids: - return output - - folders_by_id.update({ - folder_entity["id"]: folder_entity - for folder_entity in ayon_api.get_folders( - project_name, folder_ids=folder_ids - ) - }) - return output + def _clear_items(self): + root_item = self.invisibleRootItem() + root_item.removeRows(0, root_item.rowCount()) class FilterProxyModel(QtCore.QSortFilterProxyModel): """Filter model to where key column's value is in the filtered tags""" def __init__(self, *args, **kwargs): - super(FilterProxyModel, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) + self.setDynamicSortFilter(True) + self.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive) self._filter_outdated = False self._hierarchy_view = False @@ -467,28 +340,23 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel): # Always allow bottom entries (individual containers), since their # parent group hidden if it wouldn't have been validated. - rows = model.rowCount(source_index) - if not rows: + if source_index.data(IS_CONTAINER_ITEM_ROLE): return True - # Filter by regex - if hasattr(self, "filterRegExp"): - regex = self.filterRegExp() - else: - regex = self.filterRegularExpression() - pattern = regex.pattern() - if pattern: - pattern = re.escape(pattern) - - if not self._matches(row, parent, pattern): - return False - if self._filter_outdated: # When filtering to outdated we filter the up to date entries # thus we "allow" them when they are outdated - if not self._is_outdated(row, parent): + if source_index.data(VERSION_IS_LATEST_ROLE): return False + # Filter by regex + if hasattr(self, "filterRegularExpression"): + regex = self.filterRegularExpression() + else: + regex = self.filterRegExp() + + if not self._matches(row, parent, regex.pattern()): + return False return True def set_filter_outdated(self, state): @@ -505,37 +373,6 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel): if state != self._hierarchy_view: self._hierarchy_view = state - def _is_outdated(self, row, parent): - """Return whether row is outdated. - - A row is considered outdated if `isOutdated` data is true or not set. - - """ - def outdated(node): - return node.get("isOutdated", True) - - index = self.sourceModel().index(row, self.filterKeyColumn(), parent) - - # The scene contents are grouped by "representation", e.g. the same - # "representation" loaded twice is grouped under the same header. - # Since the version check filters these parent groups we skip that - # check for the individual children. - has_parent = index.parent().isValid() - if has_parent and not self._hierarchy_view: - return True - - # Filter to those that have the different version numbers - node = index.internalPointer() - if outdated(node): - return True - - if self._hierarchy_view: - for _node in walk_hierarchy(node): - if outdated(_node): - return True - - return False - def _matches(self, row, parent, pattern): """Return whether row matches regex pattern. @@ -548,38 +385,31 @@ class FilterProxyModel(QtCore.QSortFilterProxyModel): bool """ + if not pattern: + return True + + flags = 0 + if self.sortCaseSensitivity() == QtCore.Qt.CaseInsensitive: + flags = re.IGNORECASE + + regex = re.compile(re.escape(pattern), flags=flags) + model = self.sourceModel() column = self.filterKeyColumn() role = self.filterRole() - def matches(row, parent, pattern): + matches_queue = collections.deque() + matches_queue.append((row, parent)) + while matches_queue: + queue_item = matches_queue.popleft() + row, parent = queue_item + index = model.index(row, column, parent) - key = model.data(index, role) - if re.search(pattern, key, re.IGNORECASE): + value = model.data(index, role) + if regex.search(value): return True - if matches(row, parent, pattern): - return True + for idx in range(model.rowCount(index)): + matches_queue.append((idx, index)) - # Also allow if any of the children matches - source_index = model.index(row, column, parent) - rows = model.rowCount(source_index) - - if any( - matches(idx, source_index, pattern) - for idx in range(rows) - ): - return True - - if not self._hierarchy_view: - return False - - for idx in range(rows): - child_index = model.index(idx, column, source_index) - child_rows = model.rowCount(child_index) - return any( - self._matches(child_idx, child_index, pattern) - for child_idx in range(child_rows) - ) - - return True + return False diff --git a/client/ayon_core/tools/sceneinventory/models/__init__.py b/client/ayon_core/tools/sceneinventory/models/__init__.py index f840a45aa8..28bc7be4d4 100644 --- a/client/ayon_core/tools/sceneinventory/models/__init__.py +++ b/client/ayon_core/tools/sceneinventory/models/__init__.py @@ -1,6 +1,8 @@ +from .containers import ContainersModel from .sitesync import SiteSyncModel __all__ = ( + "ContainersModel", "SiteSyncModel", ) diff --git a/client/ayon_core/tools/sceneinventory/models/containers.py b/client/ayon_core/tools/sceneinventory/models/containers.py new file mode 100644 index 0000000000..5230827ef6 --- /dev/null +++ b/client/ayon_core/tools/sceneinventory/models/containers.py @@ -0,0 +1,343 @@ +import uuid +import collections + +import ayon_api +from ayon_api.graphql import GraphQlQuery +from ayon_core.host import ILoadHost + + +# --- Implementation that should be in ayon-python-api --- +# The implementation is not available in all versions of ayon-python-api. +RepresentationHierarchy = collections.namedtuple( + "RepresentationHierarchy", + ("folder", "product", "version", "representation") +) + + +def representations_parent_ids_qraphql_query(): + query = GraphQlQuery("RepresentationsHierarchyQuery") + + project_name_var = query.add_variable("projectName", "String!") + repre_ids_var = query.add_variable("representationIds", "[String!]") + + project_field = query.add_field("project") + project_field.set_filter("name", project_name_var) + + repres_field = project_field.add_field_with_edges("representations") + repres_field.add_field("id") + repres_field.add_field("name") + repres_field.set_filter("ids", repre_ids_var) + version_field = repres_field.add_field("version") + version_field.add_field("id") + product_field = version_field.add_field("product") + product_field.add_field("id") + product_field.add_field("name") + product_field.add_field("productType") + product_attrib_field = product_field.add_field("attrib") + product_attrib_field.add_field("productGroup") + folder_field = product_field.add_field("folder") + folder_field.add_field("id") + folder_field.add_field("path") + return query + + +def get_representations_hierarchy(project_name, representation_ids): + """Find representations parents by representation id. + + Representation parent entities up to project. + + Args: + project_name (str): Project where to look for entities. + representation_ids (Iterable[str]): Representation ids. + + Returns: + dict[str, RepresentationParents]: Parent entities by + representation id. + + """ + if not representation_ids: + return {} + + repre_ids = set(representation_ids) + output = { + repre_id: RepresentationHierarchy(None, None, None, None) + for repre_id in representation_ids + } + + query = representations_parent_ids_qraphql_query() + query.set_variable_value("projectName", project_name) + query.set_variable_value("representationIds", list(repre_ids)) + + con = ayon_api.get_server_api_connection() + parsed_data = query.query(con) + for repre in parsed_data["project"]["representations"]: + repre_id = repre["id"] + version = repre.pop("version") + product = version.pop("product") + folder = product.pop("folder") + + output[repre_id] = RepresentationHierarchy( + folder, product, version, repre + ) + + return output +# --- END of ayon-python-api implementation --- + + +class ContainerItem: + def __init__( + self, + representation_id, + loader_name, + namespace, + name, + object_name, + item_id + ): + self.representation_id = representation_id + self.loader_name = loader_name + self.object_name = object_name + self.namespace = namespace + self.name = name + self.item_id = item_id + + @classmethod + def from_container_data(cls, container): + return cls( + representation_id=container["representation"], + loader_name=container["loader"], + namespace=container["namespace"], + name=container["name"], + object_name=container["objectName"], + item_id=uuid.uuid4().hex, + ) + + +class RepresentationInfo: + def __init__( + self, + folder_id, + folder_path, + product_id, + product_name, + product_type, + product_group, + version_id, + representation_name, + ): + self.folder_id = folder_id + self.folder_path = folder_path + self.product_id = product_id + self.product_name = product_name + self.product_type = product_type + self.product_group = product_group + self.version_id = version_id + self.representation_name = representation_name + self._is_valid = None + + @property + def is_valid(self): + if self._is_valid is None: + self._is_valid = ( + self.folder_id is not None + and self.product_id is not None + and self.version_id is not None + and self.representation_name is not None + ) + return self._is_valid + + @classmethod + def new_invalid(cls): + return cls(None, None, None, None, None, None, None, None) + + +class VersionItem: + def __init__(self, version_id, product_id, version, status, is_latest): + self.version = version + self.version_id = version_id + self.product_id = product_id + self.version = version + self.status = status + self.is_latest = is_latest + + @property + def is_hero(self): + return self.version < 0 + + @classmethod + def from_entity(cls, version_entity, is_latest): + return cls( + version_id=version_entity["id"], + product_id=version_entity["productId"], + version=version_entity["version"], + status=version_entity["status"], + is_latest=is_latest, + ) + + +class ContainersModel: + def __init__(self, controller): + self._controller = controller + self._items_cache = None + self._containers_by_id = {} + self._container_items_by_id = {} + self._version_items_by_product_id = {} + self._repre_info_by_id = {} + + def reset(self): + self._items_cache = None + self._containers_by_id = {} + self._container_items_by_id = {} + self._version_items_by_product_id = {} + self._repre_info_by_id = {} + + def get_containers(self): + self._update_cache() + return list(self._containers_by_id.values()) + + def get_containers_by_item_ids(self, item_ids): + return { + item_id: self._containers_by_id.get(item_id) + for item_id in item_ids + } + + def get_container_items(self): + self._update_cache() + return list(self._items_cache) + + def get_container_items_by_id(self, item_ids): + return { + item_id: self._container_items_by_id.get(item_id) + for item_id in item_ids + } + + def get_representation_info_items(self, representation_ids): + output = {} + missing_repre_ids = set() + for repre_id in representation_ids: + try: + uuid.UUID(repre_id) + except ValueError: + output[repre_id] = RepresentationInfo.new_invalid() + continue + + repre_info = self._repre_info_by_id.get(repre_id) + if repre_info is None: + missing_repre_ids.add(repre_id) + else: + output[repre_id] = repre_info + + if not missing_repre_ids: + return output + + project_name = self._controller.get_current_project_name() + repre_hierarchy_by_id = get_representations_hierarchy( + project_name, missing_repre_ids + ) + for repre_id, repre_hierarchy in repre_hierarchy_by_id.items(): + kwargs = { + "folder_id": None, + "folder_path": None, + "product_id": None, + "product_name": None, + "product_type": None, + "product_group": None, + "version_id": None, + "representation_name": None, + } + folder = repre_hierarchy.folder + product = repre_hierarchy.product + version = repre_hierarchy.version + repre = repre_hierarchy.representation + if folder: + kwargs["folder_id"] = folder["id"] + kwargs["folder_path"] = folder["path"] + if product: + group = product["attrib"]["productGroup"] + kwargs["product_id"] = product["id"] + kwargs["product_name"] = product["name"] + kwargs["product_type"] = product["productType"] + kwargs["product_group"] = group + if version: + kwargs["version_id"] = version["id"] + if repre: + kwargs["representation_name"] = repre["name"] + + repre_info = RepresentationInfo(**kwargs) + self._repre_info_by_id[repre_id] = repre_info + output[repre_id] = repre_info + return output + + def get_version_items(self, product_ids): + if not product_ids: + return {} + + missing_ids = { + product_id + for product_id in product_ids + if product_id not in self._version_items_by_product_id + } + if missing_ids: + def version_sorted(entity): + return entity["version"] + + project_name = self._controller.get_current_project_name() + version_entities_by_product_id = { + product_id: [] + for product_id in missing_ids + } + + version_entities = list(ayon_api.get_versions( + project_name, + product_ids=missing_ids, + fields={"id", "version", "productId", "status"} + )) + version_entities.sort(key=version_sorted) + for version_entity in version_entities: + product_id = version_entity["productId"] + version_entities_by_product_id[product_id].append( + version_entity + ) + + for product_id, version_entities in ( + version_entities_by_product_id.items() + ): + last_version = abs(version_entities[-1]["version"]) + version_items_by_id = { + entity["id"]: VersionItem.from_entity( + entity, abs(entity["version"]) == last_version + ) + for entity in version_entities + } + self._version_items_by_product_id[product_id] = ( + version_items_by_id + ) + + return { + product_id: dict(self._version_items_by_product_id[product_id]) + for product_id in product_ids + } + + def _update_cache(self): + if self._items_cache is not None: + return + + host = self._controller.get_host() + if isinstance(host, ILoadHost): + containers = list(host.get_containers()) + elif hasattr(host, "ls"): + containers = list(host.ls()) + else: + containers = [] + container_items = [] + containers_by_id = {} + container_items_by_id = {} + for container in containers: + item = ContainerItem.from_container_data(container) + containers_by_id[item.item_id] = container + container_items_by_id[item.item_id] = item + container_items.append(item) + + self._containers_by_id = containers_by_id + self._container_items_by_id = container_items_by_id + self._items_cache = container_items diff --git a/client/ayon_core/tools/sceneinventory/view.py b/client/ayon_core/tools/sceneinventory/view.py index 5cbd4daf70..9dcf3349e6 100644 --- a/client/ayon_core/tools/sceneinventory/view.py +++ b/client/ayon_core/tools/sceneinventory/view.py @@ -1,11 +1,8 @@ -import uuid import collections import logging -import itertools from functools import partial -import ayon_api -from qtpy import QtWidgets, QtCore +from qtpy import QtWidgets, QtCore, QtGui import qtawesome from ayon_core import style @@ -17,12 +14,21 @@ from ayon_core.pipeline import ( ) from ayon_core.tools.utils.lib import ( iter_model_rows, - format_version + format_version, + preserve_expanded_rows, + preserve_selection, ) from .switch_dialog import SwitchAssetDialog -from .model import InventoryModel - +from .model import ( + InventoryModel, + FilterProxyModel, + ITEM_UNIQUE_NAME_ROLE, + OBJECT_NAME_ROLE, + ITEM_ID_ROLE, + IS_CONTAINER_ITEM_ROLE, +) +from .delegates import VersionDelegate DEFAULT_COLOR = "#fb9c15" @@ -43,185 +49,187 @@ class SceneInventoryView(QtWidgets.QTreeView): self.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection) self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) + model = InventoryModel(controller) + proxy_model = FilterProxyModel() + proxy_model.setSourceModel(model) + + self.setModel(proxy_model) + + version_delegate = VersionDelegate() + self.setItemDelegateForColumn(model.version_col, version_delegate) + + # set some nice default widths for the view + for col, width in model.width_by_column.items(): + self.setColumnWidth(col, width) + + sync_enabled = controller.is_sitesync_enabled() + self.setColumnHidden(model.active_site_col, not sync_enabled) + self.setColumnHidden(model.remote_site_col, not sync_enabled) + self.customContextMenuRequested.connect(self._show_right_mouse_menu) + self._model = model + self._proxy_model = proxy_model + self._version_delegate = version_delegate + self._hierarchy_view = False self._selected = None self._controller = controller + def refresh(self): + with preserve_expanded_rows( + tree_view=self, + role=ITEM_UNIQUE_NAME_ROLE + ): + with preserve_selection( + tree_view=self, + role=ITEM_UNIQUE_NAME_ROLE, + current_index=False + ): + kwargs = {} + # TODO do not touch view's inner attribute + if self._hierarchy_view: + kwargs["selected"] = self._selected + self._model.refresh(**kwargs) + + def set_hierarchy_view(self, enabled): + self._proxy.set_hierarchy_view(enabled) + self._model.set_hierarchy_view(enabled) + + def set_text_filter(self, text_filter): + if hasattr(self._proxy, "setFilterRegularExpression"): + self._proxy.setFilterRegularExpression(text_filter) + else: + self._proxy.setFilterRegExp(text_filter) + + def set_filter_outdated(self, enabled): + self._proxy.set_filter_outdated(enabled) + + def get_selected_indexes(self): + """Get the selected rows""" + indexes, _ = self._get_selected_indexes() + return indexes + + def get_selected_item_ids(self): + return self._get_item_ids_from_indexes( + self.get_selected_indexes() + ) + + def get_selected_container_indexes(self): + return self._get_container_indexes( + self.get_selected_indexes() + ) + + def _get_selected_indexes(self): + selection_model = self.selectionModel() + indexes = selection_model.selectedRows() + active = self.currentIndex() + active = active.sibling(active.row(), 0) + if active not in indexes: + indexes.append(active) + return indexes, active + + def _get_item_ids_from_indexes(self, indexes): + return { + index.data(ITEM_ID_ROLE) + for index in self._get_container_indexes(indexes) + } + def _set_hierarchy_view(self, enabled): if enabled == self._hierarchy_view: return self._hierarchy_view = enabled self.hierarchy_view_changed.emit(enabled) - def _enter_hierarchy(self, items): - self._selected = set(i["objectName"] for i in items) + def _enter_hierarchy(self, item_ids): + self._selected = set(item_ids) self._set_hierarchy_view(True) self.data_changed.emit() self.expandToDepth(1) - self.setStyleSheet(""" - QTreeView { - border-color: #fb9c15; - } - """) + self.setStyleSheet("border-color: #fb9c15;") def _leave_hierarchy(self): self._set_hierarchy_view(False) self.data_changed.emit() - self.setStyleSheet("QTreeView {}") + self.setStyleSheet("") - def _build_item_menu_for_selection(self, items, menu): - # Exclude items that are "NOT FOUND" since setting versions, updating - # and removal won't work for those items. - items = [item for item in items if not item.get("isNotFound")] - if not items: + def _build_item_menu_for_selection(self, menu, indexes, active_index): + item_ids = { + index.data(ITEM_ID_ROLE) + for index in indexes + } + item_ids.discard(None) + if not item_ids: return - # An item might not have a representation, for example when an item - # is listed as "NOT FOUND" - repre_ids = set() - for item in items: - repre_id = item["representation"] - try: - uuid.UUID(repre_id) - repre_ids.add(repre_id) - except ValueError: - pass - - project_name = self._controller.get_current_project_name() - repre_entities = ayon_api.get_representations( - project_name, - representation_ids=repre_ids, - fields={"versionId"} + container_items_by_id = self._controller.get_container_items_by_id( + item_ids ) - version_ids = { - repre_entity["versionId"] - for repre_entity in repre_entities + active_repre_id = None + if active_index is not None: + for index in self._get_container_indexes({active_index}): + item_id = index.data(ITEM_ID_ROLE) + container_item = container_items_by_id[item_id] + active_repre_id = container_item.representation_id + break + + repre_info_by_id = self._controller.get_representation_info_items({ + container_item.representation_id + for container_item in container_items_by_id.values() + }) + valid_repre_ids = { + repre_id + for repre_id, repre_info in repre_info_by_id.items() + if repre_info.is_valid } - loaded_versions = ayon_api.get_versions( - project_name, version_ids=version_ids - ) - - loaded_hero_versions = [] - versions_by_product_id = collections.defaultdict(list) + # Exclude items that are "NOT FOUND" since setting versions, updating + # and removal won't work for those items. + filtered_items = [] product_ids = set() - for version_entity in loaded_versions: - version = version_entity["version"] - if version < 0: - loaded_hero_versions.append(version_entity) - else: - product_id = version_entity["productId"] - versions_by_product_id[product_id].append(version_entity) - product_ids.add(product_id) + version_ids = set() + for container_item in container_items_by_id.values(): + repre_id = container_item.representation_id + repre_info = repre_info_by_id.get(repre_id) + if repre_info and repre_info.is_valid: + filtered_items.append(container_item) + version_ids.add(repre_info.version_id) + product_ids.add(repre_info.product_id) - all_versions = ayon_api.get_versions( - project_name, product_ids=product_ids + # remove + remove_icon = qtawesome.icon("fa.remove", color=DEFAULT_COLOR) + remove_action = QtWidgets.QAction(remove_icon, "Remove items", menu) + remove_action.triggered.connect( + lambda: self._show_remove_warning_dialog(item_ids)) + + if not filtered_items: + # Keep remove action for invalid items + menu.addAction(remove_action) + return + + version_items_by_product_id = self._controller.get_version_items( + product_ids ) - hero_versions = [] - version_entities = [] - for version_entity in all_versions: - version = version_entity["version"] - if version < 0: - hero_versions.append(version_entity) - else: - version_entities.append(version_entity) - - has_loaded_hero_versions = len(loaded_hero_versions) > 0 - has_available_hero_version = len(hero_versions) > 0 has_outdated = False + has_loaded_hero_versions = False + has_available_hero_version = False + for version_items_by_id in version_items_by_product_id.values(): + for version_item in version_items_by_id.values(): + if version_item.is_hero: + has_available_hero_version = True - for version_entity in version_entities: - product_id = version_entity["productId"] - current_versions = versions_by_product_id[product_id] - for current_version in current_versions: - if current_version["version"] < version_entity["version"]: + if version_item.version_id not in version_ids: + continue + if version_item.is_hero: + has_loaded_hero_versions = True + + elif not version_item.is_latest: has_outdated = True - break - - if has_outdated: - break switch_to_versioned = None if has_loaded_hero_versions: - def _on_switch_to_versioned(items): - repre_ids = { - item["representation"] - for item in items - } - - repre_entities = ayon_api.get_representations( - project_name, - representation_ids=repre_ids, - fields={"id", "versionId"} - ) - - version_id_by_repre_id = {} - for repre_entity in repre_entities: - repre_id = repre_entity["id"] - version_id = repre_entity["versionId"] - version_id_by_repre_id[repre_id] = version_id - version_ids = set(version_id_by_repre_id.values()) - - src_version_entity_by_id = { - version_entity["id"]: version_entity - for version_entity in ayon_api.get_versions( - project_name, - version_ids, - fields={"productId", "version"} - ) - } - hero_versions_by_product_id = {} - for version_entity in src_version_entity_by_id.values(): - version = version_entity["version"] - if version < 0: - product_id = version_entity["productId"] - hero_versions_by_product_id[product_id] = abs(version) - - if not hero_versions_by_product_id: - return - - standard_versions = ayon_api.get_versions( - project_name, - product_ids=hero_versions_by_product_id.keys(), - versions=hero_versions_by_product_id.values() - ) - standard_version_by_product_id = { - product_id: {} - for product_id in hero_versions_by_product_id.keys() - } - for version_entity in standard_versions: - product_id = version_entity["productId"] - version = version_entity["version"] - standard_version_by_product_id[product_id][version] = ( - version_entity - ) - - # Specify version per item to update to - update_items = [] - update_versions = [] - for item in items: - repre_id = item["representation"] - version_id = version_id_by_repre_id.get(repre_id) - version_entity = src_version_entity_by_id.get(version_id) - if not version_entity or version_entity["version"] >= 0: - continue - product_id = version_entity["productId"] - version_entities_by_version = ( - standard_version_by_product_id[product_id] - ) - new_version = hero_versions_by_product_id.get(product_id) - new_version_entity = version_entities_by_version.get( - new_version - ) - if new_version_entity is not None: - update_items.append(item) - update_versions.append(new_version) - self._update_containers(update_items, update_versions) - update_icon = qtawesome.icon( "fa.asterisk", color=DEFAULT_COLOR @@ -232,7 +240,7 @@ class SceneInventoryView(QtWidgets.QTreeView): menu ) switch_to_versioned.triggered.connect( - lambda: _on_switch_to_versioned(items) + lambda: self._on_switch_to_versioned(item_ids) ) update_to_latest_action = None @@ -247,7 +255,9 @@ class SceneInventoryView(QtWidgets.QTreeView): menu ) update_to_latest_action.triggered.connect( - lambda: self._update_containers(items, version=-1) + lambda: self._update_containers_to_version( + item_ids, version=-1 + ) ) change_to_hero = None @@ -263,20 +273,23 @@ class SceneInventoryView(QtWidgets.QTreeView): menu ) change_to_hero.triggered.connect( - lambda: self._update_containers( - items, version=HeroVersionType(-1) + lambda: self._update_containers_to_version( + item_ids, version=HeroVersionType(-1) ) ) # set version - set_version_icon = qtawesome.icon("fa.hashtag", color=DEFAULT_COLOR) - set_version_action = QtWidgets.QAction( - set_version_icon, - "Set version", - menu - ) - set_version_action.triggered.connect( - lambda: self._show_version_dialog(items)) + set_version_action = None + if active_repre_id is not None: + set_version_icon = qtawesome.icon("fa.hashtag", color=DEFAULT_COLOR) + set_version_action = QtWidgets.QAction( + set_version_icon, + "Set version", + menu + ) + set_version_action.triggered.connect( + lambda: self._show_version_dialog(item_ids, active_repre_id) + ) # switch folder switch_folder_icon = qtawesome.icon("fa.sitemap", color=DEFAULT_COLOR) @@ -286,13 +299,7 @@ class SceneInventoryView(QtWidgets.QTreeView): menu ) switch_folder_action.triggered.connect( - lambda: self._show_switch_dialog(items)) - - # remove - remove_icon = qtawesome.icon("fa.remove", color=DEFAULT_COLOR) - remove_action = QtWidgets.QAction(remove_icon, "Remove items", menu) - remove_action.triggered.connect( - lambda: self._show_remove_warning_dialog(items)) + lambda: self._show_switch_dialog(item_ids)) # add the actions if switch_to_versioned: @@ -304,14 +311,15 @@ class SceneInventoryView(QtWidgets.QTreeView): if change_to_hero: menu.addAction(change_to_hero) - menu.addAction(set_version_action) + if set_version_action is not None: + menu.addAction(set_version_action) menu.addAction(switch_folder_action) menu.addSeparator() menu.addAction(remove_action) - self._handle_sitesync(menu, repre_ids) + self._handle_sitesync(menu, valid_repre_ids) def _handle_sitesync(self, menu, repre_ids): """Adds actions for download/upload when SyncServer is enabled @@ -327,6 +335,9 @@ class SceneInventoryView(QtWidgets.QTreeView): if not self._controller.is_sitesync_enabled(): return + if not repre_ids: + return + menu.addSeparator() download_icon = qtawesome.icon("fa.download", color=DEFAULT_COLOR) @@ -365,30 +376,35 @@ class SceneInventoryView(QtWidgets.QTreeView): self.data_changed.emit() - def _build_item_menu(self, items=None): + def _build_item_menu(self, indexes=None, active_index=None): """Create menu for the selected items""" - - if not items: - items = [] - menu = QtWidgets.QMenu(self) - # add the actions - self._build_item_menu_for_selection(items, menu) - # These two actions should be able to work without selection # expand all items - expandall_action = QtWidgets.QAction(menu, text="Expand all items") - expandall_action.triggered.connect(self.expandAll) + expand_all_action = QtWidgets.QAction(menu, text="Expand all items") + expand_all_action.triggered.connect(self.expandAll) # collapse all items collapse_action = QtWidgets.QAction(menu, text="Collapse all items") collapse_action.triggered.connect(self.collapseAll) - menu.addAction(expandall_action) + if not indexes: + indexes = [] + + item_ids = { + index.data(ITEM_ID_ROLE) + for index in indexes + } + item_ids.discard(None) + + # add the actions + self._build_item_menu_for_selection(menu, indexes, active_index) + + menu.addAction(expand_all_action) menu.addAction(collapse_action) - custom_actions = self._get_custom_actions(containers=items) + custom_actions = self._get_custom_actions(item_ids) if custom_actions: submenu = QtWidgets.QMenu("Actions", self) for action in custom_actions: @@ -396,7 +412,10 @@ class SceneInventoryView(QtWidgets.QTreeView): icon = qtawesome.icon("fa.%s" % action.icon, color=color) action_item = QtWidgets.QAction(icon, action.label, submenu) action_item.triggered.connect( - partial(self._process_custom_action, action, items)) + partial( + self._process_custom_action, action, item_ids + ) + ) submenu.addAction(action_item) @@ -421,9 +440,9 @@ class SceneInventoryView(QtWidgets.QTreeView): menu ) enter_hierarchy_action.triggered.connect( - lambda: self._enter_hierarchy(items)) + lambda: self._enter_hierarchy(item_ids)) - if items: + if indexes: menu.addAction(enter_hierarchy_action) if back_to_flat_action is not None: @@ -431,11 +450,11 @@ class SceneInventoryView(QtWidgets.QTreeView): return menu - def _get_custom_actions(self, containers): + def _get_custom_actions(self, item_ids): """Get the registered Inventory Actions Args: - containers(list): collection of containers + item_ids (Iterable[str]): collection of containers Returns: list: collection of filter and initialized actions @@ -448,29 +467,40 @@ class SceneInventoryView(QtWidgets.QTreeView): # Fedd an empty dict if no selection, this will ensure the compat # lookup always work, so plugin can interact with Scene Inventory # reversely. - containers = containers or [dict()] + if not item_ids: + containers = [dict()] + else: + containers_by_id = self._controller.get_containers_by_item_ids( + item_ids + ) + containers = list(containers_by_id.values()) # Check which action will be available in the menu Plugins = discover_inventory_actions() - compatible = [p() for p in Plugins if - any(p.is_compatible(c) for c in containers)] + compatible = [ + p() + for p in Plugins + if any(p.is_compatible(c) for c in containers) + ] return sorted(compatible, key=sorter) - def _process_custom_action(self, action, containers): + def _process_custom_action(self, action, item_ids): """Run action and if results are returned positive update the view If the result is list or dict, will select view items by the result. Args: action (InventoryAction): Inventory Action instance - containers (list): Data of currently selected items + item_ids (Iterable[str]): Data of currently selected items Returns: None """ - - result = action.process(containers) + containers_by_id = self._controller.get_containers_by_item_ids( + item_ids + ) + result = action.process(list(containers_by_id.values())) if result: self.data_changed.emit() @@ -498,17 +528,24 @@ class SceneInventoryView(QtWidgets.QTreeView): if options.get("clear", True): self.clearSelection() - object_names = set(object_names) - if ( - self._hierarchy_view - and not self._selected.issuperset(object_names) - ): - # If any container not in current cherry-picked view, update - # view before selecting them. - self._selected.update(object_names) - self.data_changed.emit() - model = self.model() + object_names = set(object_names) + if self._hierarchy_view: + item_ids = set() + for index in iter_model_rows(model): + if not index.data(IS_CONTAINER_ITEM_ROLE): + continue + if index.data(OBJECT_NAME_ROLE) in object_names: + item_id = index.data(ITEM_ID_ROLE) + if item_id: + item_ids.add(item_id) + + if not self._selected.issuperset(item_ids): + # If any container not in current cherry-picked view, update + # view before selecting them. + self._selected.update(item_ids) + self.data_changed.emit() + selection_model = self.selectionModel() select_mode = { @@ -517,12 +554,10 @@ class SceneInventoryView(QtWidgets.QTreeView): "toggle": QtCore.QItemSelectionModel.Toggle, }[options.get("mode", "select")] - for index in iter_model_rows(model, 0): - item = index.data(InventoryModel.ItemRole) - if item.get("isGroupNode"): + for index in iter_model_rows(model): + if not index.data(IS_CONTAINER_ITEM_ROLE): continue - - name = item.get("objectName") + name = index.data(OBJECT_NAME_ROLE) if name in object_names: self.scrollTo(index) # Ensure item is visible flags = select_mode | QtCore.QItemSelectionModel.Rows @@ -539,143 +574,140 @@ class SceneInventoryView(QtWidgets.QTreeView): globalpos = self.viewport().mapToGlobal(pos) if not self.selectionModel().hasSelection(): - print("No selection") # Build menu without selection, feed an empty list menu = self._build_item_menu() menu.exec_(globalpos) return - active = self.currentIndex() # index under mouse - active = active.sibling(active.row(), 0) # get first column - - # move index under mouse - indices = self.get_indices() - if active in indices: - indices.remove(active) - - indices.append(active) + indexes, active_index = self._get_selected_indexes() # Extend to the sub-items - all_indices = self._extend_to_children(indices) - items = [dict(i.data(InventoryModel.ItemRole)) for i in all_indices - if i.parent().isValid()] + all_indexes = self._extend_to_children(indexes) - if self._hierarchy_view: - # Ensure no group item - items = [n for n in items if not n.get("isGroupNode")] - - menu = self._build_item_menu(items) + menu = self._build_item_menu(all_indexes, active_index) menu.exec_(globalpos) - def get_indices(self): - """Get the selected rows""" - selection_model = self.selectionModel() - return selection_model.selectedRows() + def _get_container_indexes(self, indexes): + container_indexes = [] + indexes_queue = collections.deque() + indexes_queue.extend(indexes) + # Ignore already added containers + items_ids = set() + while indexes_queue: + index = indexes_queue.popleft() + if index.data(IS_CONTAINER_ITEM_ROLE): + item_id = index.data(ITEM_ID_ROLE) + if item_id in items_ids: + continue + items_ids.add(item_id) + container_indexes.append(index) + continue + model = index.model() + for row in range(model.rowCount(index)): + child = model.index(row, 0, parent=index) + indexes_queue.append(child) + return container_indexes - def _extend_to_children(self, indices): + def _extend_to_children(self, indexes): """Extend the indices to the children indices. Top-level indices are extended to its children indices. Sub-items are kept as is. Args: - indices (list): The indices to extend. + indexes (list): The indices to extend. Returns: list: The children indices """ - def get_children(i): - model = i.model() - rows = model.rowCount(parent=i) - for row in range(rows): - child = model.index(row, 0, parent=i) - yield child + def get_children(index): + model = index.model() + for row in range(model.rowCount(index)): + yield model.index(row, 0, parent=index) subitems = set() - for i in indices: - valid_parent = i.parent().isValid() - if valid_parent and i not in subitems: - subitems.add(i) + for index in indexes: + if index.parent().isValid() and index not in subitems: + subitems.add(index) if self._hierarchy_view: # Assume this is a group item - for child in get_children(i): + for child in get_children(index): subitems.add(child) else: # is top level item - for child in get_children(i): + for child in get_children(index): subitems.add(child) return list(subitems) - def _show_version_dialog(self, items): + def _show_version_dialog(self, item_ids, active_repre_id): """Create a dialog with the available versions for the selected file Args: - items (list): list of items to run the "set_version" for + item_ids (Iterable[str]): List of item ids to run the + "set_version" for. + active_repre_id (Union[str, None]): Active representation id. Returns: None + """ - - active = items[-1] - - project_name = self._controller.get_current_project_name() - # Get available versions for active representation - repre_entity = ayon_api.get_representation_by_id( - project_name, - active["representation"], - fields={"versionId"} + container_items_by_id = self._controller.get_container_items_by_id( + item_ids + ) + repre_ids = { + container_item.representation_id + for container_item in container_items_by_id.values() + } + repre_info_by_id = self._controller.get_representation_info_items( + repre_ids ) - repre_version_entity = ayon_api.get_version_by_id( - project_name, - repre_entity["versionId"], - fields={"productId"} - ) + active_repre_info = repre_info_by_id[active_repre_id] + active_product_id = active_repre_info.product_id + active_version_id = active_repre_info.version_id + filtered_repre_info_by_id = { + repre_id: repre_info + for repre_id, repre_info in repre_info_by_id.items() + if repre_info.product_id == active_product_id + } + filtered_container_item_ids = { + item_id + for item_id, container_item in container_items_by_id.items() + if container_item.representation_id in filtered_repre_info_by_id + } + version_items_by_id = self._controller.get_version_items( + {active_product_id} + )[active_product_id] - version_entities = list(ayon_api.get_versions( - project_name, - product_ids={repre_version_entity["productId"]}, - )) - hero_version = None - standard_versions = [] - for version_entity in version_entities: - if version_entity["version"] < 0: - hero_version = version_entity - else: - standard_versions.append(version_entity) - standard_versions.sort(key=lambda item: item["version"]) - standard_versions.reverse() + def version_sorter(item): + hero_value = 0 + version = item.version + if version < 0: + hero_value = 1 + version = abs(version) + return version, hero_value - # Get index among the listed versions - current_item = None - current_version = active["version"] - if isinstance(current_version, HeroVersionType): - current_item = hero_version - else: - for version_entity in standard_versions: - if version_entity["version"] == current_version: - current_item = version_entity - break + version_items = list(version_items_by_id.values()) + version_items.sort(key=version_sorter, reverse=True) - all_versions = [] - if hero_version: - all_versions.append(hero_version) - all_versions.extend(standard_versions) - - if current_item: - index = all_versions.index(current_item) - else: - index = 0 - - versions_by_label = dict() + versions_by_label = {} labels = [] - for version_entity in all_versions: - label = format_version(version_entity["version"]) + active_version_label = None + for version_item in version_items: + version = version_item.version + label = format_version(version) + if version_item.version_id == active_version_id: + active_version_label = label + labels.append(label) - versions_by_label[label] = version_entity["version"] + versions_by_label[label] = version + + index = 0 + if active_version_label in labels: + index = labels.index(active_version_label) label, state = QtWidgets.QInputDialog.getItem( self, @@ -692,24 +724,35 @@ class SceneInventoryView(QtWidgets.QTreeView): version = versions_by_label[label] if version < 0: version = HeroVersionType(version) - self._update_containers(items, version) - def _show_switch_dialog(self, items): + self._update_containers_to_version( + filtered_container_item_ids, version + ) + + def _show_switch_dialog(self, item_ids): """Display Switch dialog""" - dialog = SwitchAssetDialog(self._controller, self, items) + containers_by_id = self._controller.get_containers_by_item_ids( + item_ids + ) + dialog = SwitchAssetDialog( + self._controller, self, list(containers_by_id.values()) + ) dialog.switched.connect(self.data_changed.emit) dialog.show() - def _show_remove_warning_dialog(self, items): + def _show_remove_warning_dialog(self, item_ids): """Prompt a dialog to inform the user the action will remove items""" - + containers_by_id = self._controller.get_containers_by_item_ids( + item_ids + ) + containers = list(containers_by_id.values()) accept = QtWidgets.QMessageBox.Ok buttons = accept | QtWidgets.QMessageBox.Cancel state = QtWidgets.QMessageBox.question( self, "Are you sure?", - "Are you sure you want to remove {} item(s)".format(len(items)), + f"Are you sure you want to remove {len(containers)} item(s)", buttons=buttons, defaultButton=accept ) @@ -717,15 +760,15 @@ class SceneInventoryView(QtWidgets.QTreeView): if state != accept: return - for item in items: - remove_container(item) + for container in containers: + remove_container(container) self.data_changed.emit() - def _show_version_error_dialog(self, version, items): + def _show_version_error_dialog(self, version, item_ids): """Shows QMessageBox when version switch doesn't work - Args: - version: str or int or None + Args: + version: str or int or None """ if version == -1: version_str = "latest" @@ -745,7 +788,7 @@ class SceneInventoryView(QtWidgets.QTreeView): "Switch Folder", QtWidgets.QMessageBox.ActionRole ) - switch_btn.clicked.connect(lambda: self._show_switch_dialog(items)) + switch_btn.clicked.connect(lambda: self._show_switch_dialog(item_ids)) dialog.addButton(QtWidgets.QMessageBox.Cancel) @@ -760,69 +803,106 @@ class SceneInventoryView(QtWidgets.QTreeView): def update_all(self): """Update all items that are currently 'outdated' in the view""" # Get the source model through the proxy model - model = self.model().sourceModel() - - # Get all items from outdated groups - outdated_items = [] - for index in iter_model_rows(model, - column=0, - include_root=False): - item = index.data(model.ItemRole) - - if not item.get("isGroupNode"): - continue - - # Only the group nodes contain the "highest_version" data and as - # such we find only the groups and take its children. - if not model.outdated(item): - continue - - # Collect all children which we want to update - children = item.children() - outdated_items.extend(children) - - if not outdated_items: + item_ids = self._model.get_outdated_item_ids() + if not item_ids: log.info("Nothing to update.") return # Trigger update to latest - self._update_containers(outdated_items, version=-1) + self._update_containers_to_version(item_ids, version=-1) - def _update_containers(self, items, version): + def _on_switch_to_versioned(self, item_ids): + containers_items_by_id = self._controller.get_container_items_by_id( + item_ids + ) + product_ids = { + container_item.product_id + for container_item in containers_items_by_id.values() + if container_item.is_valid + } + version_items_by_product_id = self._controller.get_version_items( + product_ids + ) + + update_containers = [] + update_versions = [] + for item_id, container_item in containers_items_by_id.items(): + product_id = container_item.product_id + version_items_id = version_items_by_product_id[product_id] + version_item = version_items_id.get(container_item.version_id, {}) + if not version_item or not version_item.is_hero: + continue + version = abs(version_item.version) + version_found = False + for version_item in version_items_id.values(): + if version_item.is_hero: + continue + if version_item.version == version: + version_found = True + break + + if not version_found: + continue + + update_containers.append(container_item.item_id) + update_versions.append(version) + + # Specify version per item to update to + self._update_containers(update_containers, update_versions) + + def _update_containers(self, item_ids, versions): """Helper to update items to given version (or version per item) If at least one item is specified this will always try to refresh the inventory even if errors occurred on any of the items. Arguments: - items (list): Items to update - version (int or list): Version to set to. + item_ids (Iterable[str]): Items to update + versions (Iterable[Union[int, HeroVersion]]): Version to set to. This can be a list specifying a version for each item. Like `update_container` version -1 sets the latest version and HeroTypeVersion instances set the hero version. """ - if isinstance(version, (list, tuple)): - # We allow a unique version to be specified per item. In that case - # the length must match with the items - assert len(items) == len(version), ( - "Number of items mismatches number of versions: " - "{} items - {} versions".format(len(items), len(version)) - ) - versions = version - else: - # Repeat the same version infinitely - versions = itertools.repeat(version) + # We allow a unique version to be specified per item. In that case + # the length must match with the items + assert len(item_ids) == len(versions), ( + "Number of items mismatches number of versions: " + f"{len(item_ids)} items - {len(versions)} versions" + ) # Trigger update to latest + containers_by_id = self._controller.get_containers_by_item_ids( + item_ids + ) try: - for item, item_version in zip(items, versions): + for item_id, item_version in zip(item_ids, versions): + container = containers_by_id[item_id] try: - update_container(item, item_version) + update_container(container, item_version) except AssertionError: - self._show_version_error_dialog(item_version, [item]) log.warning("Update failed", exc_info=True) + self._show_version_error_dialog( + item_version, [item_id] + ) finally: # Always update the scene inventory view, even if errors occurred self.data_changed.emit() + + def _update_containers_to_version(self, item_ids, version): + """Helper to update items to given version (or version per item) + + If at least one item is specified this will always try to refresh + the inventory even if errors occurred on any of the items. + + Arguments: + item_ids (Iterable[str]): Items to update + version (Union[int, HeroVersion]): Version to set to. + This can be a list specifying a version for each item. + Like `update_container` version -1 sets the latest version + and HeroTypeVersion instances set the hero version. + + """ + versions = [version for _ in range(len(item_ids))] + self._update_containers(item_ids, versions) diff --git a/client/ayon_core/tools/sceneinventory/window.py b/client/ayon_core/tools/sceneinventory/window.py index 555db3a17c..58ff0c3b6d 100644 --- a/client/ayon_core/tools/sceneinventory/window.py +++ b/client/ayon_core/tools/sceneinventory/window.py @@ -2,17 +2,10 @@ from qtpy import QtWidgets, QtCore, QtGui import qtawesome from ayon_core import style, resources -from ayon_core.tools.utils.lib import ( - preserve_expanded_rows, - preserve_selection, -) +from ayon_core.tools.utils import PlaceholderLineEdit + from ayon_core.tools.sceneinventory import SceneInventoryController -from .delegates import VersionDelegate -from .model import ( - InventoryModel, - FilterProxyModel -) from .view import SceneInventoryView @@ -20,7 +13,7 @@ class SceneInventoryWindow(QtWidgets.QDialog): """Scene Inventory window""" def __init__(self, controller=None, parent=None): - super(SceneInventoryWindow, self).__init__(parent) + super().__init__(parent) if controller is None: controller = SceneInventoryController() @@ -33,10 +26,9 @@ class SceneInventoryWindow(QtWidgets.QDialog): self.resize(1100, 480) - # region control - filter_label = QtWidgets.QLabel("Search", self) - text_filter = QtWidgets.QLineEdit(self) + text_filter = PlaceholderLineEdit(self) + text_filter.setPlaceholderText("Filter by name...") outdated_only_checkbox = QtWidgets.QCheckBox( "Filter to outdated", self @@ -44,52 +36,30 @@ class SceneInventoryWindow(QtWidgets.QDialog): outdated_only_checkbox.setToolTip("Show outdated files only") outdated_only_checkbox.setChecked(False) - icon = qtawesome.icon("fa.arrow-up", color="white") + update_all_icon = qtawesome.icon("fa.arrow-up", color="white") update_all_button = QtWidgets.QPushButton(self) update_all_button.setToolTip("Update all outdated to latest version") - update_all_button.setIcon(icon) + update_all_button.setIcon(update_all_icon) - icon = qtawesome.icon("fa.refresh", color="white") + refresh_icon = qtawesome.icon("fa.refresh", color="white") refresh_button = QtWidgets.QPushButton(self) refresh_button.setToolTip("Refresh") - refresh_button.setIcon(icon) + refresh_button.setIcon(refresh_icon) - control_layout = QtWidgets.QHBoxLayout() - control_layout.addWidget(filter_label) - control_layout.addWidget(text_filter) - control_layout.addWidget(outdated_only_checkbox) - control_layout.addWidget(update_all_button) - control_layout.addWidget(refresh_button) - - model = InventoryModel(controller) - proxy = FilterProxyModel() - proxy.setSourceModel(model) - proxy.setDynamicSortFilter(True) - proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive) + headers_widget = QtWidgets.QWidget(self) + headers_layout = QtWidgets.QHBoxLayout(headers_widget) + headers_layout.setContentsMargins(0, 0, 0, 0) + headers_layout.addWidget(filter_label, 0) + headers_layout.addWidget(text_filter, 1) + headers_layout.addWidget(outdated_only_checkbox, 0) + headers_layout.addWidget(update_all_button, 0) + headers_layout.addWidget(refresh_button, 0) view = SceneInventoryView(controller, self) - view.setModel(proxy) - sync_enabled = controller.is_sitesync_enabled() - view.setColumnHidden(model.active_site_col, not sync_enabled) - view.setColumnHidden(model.remote_site_col, not sync_enabled) - - # set some nice default widths for the view - view.setColumnWidth(0, 250) # name - view.setColumnWidth(1, 55) # version - view.setColumnWidth(2, 55) # count - view.setColumnWidth(3, 150) # product type - view.setColumnWidth(4, 120) # group - view.setColumnWidth(5, 150) # loader - - # apply delegates - version_delegate = VersionDelegate(controller, self) - column = model.Columns.index("version") - view.setItemDelegateForColumn(column, version_delegate) - - layout = QtWidgets.QVBoxLayout(self) - layout.addLayout(control_layout) - layout.addWidget(view) + main_layout = QtWidgets.QVBoxLayout(self) + main_layout.addWidget(headers_widget, 0) + main_layout.addWidget(view, 1) show_timer = QtCore.QTimer() show_timer.setInterval(0) @@ -114,12 +84,8 @@ class SceneInventoryWindow(QtWidgets.QDialog): self._update_all_button = update_all_button self._outdated_only_checkbox = outdated_only_checkbox self._view = view - self._model = model - self._proxy = proxy - self._version_delegate = version_delegate self._first_show = True - self._first_refresh = True def showEvent(self, event): super(SceneInventoryWindow, self).showEvent(event) @@ -139,29 +105,16 @@ class SceneInventoryWindow(QtWidgets.QDialog): whilst trying to name an instance. """ + pass def _on_refresh_request(self): """Signal callback to trigger 'refresh' without any arguments.""" self.refresh() - def refresh(self, containers=None): - self._first_refresh = False + def refresh(self): self._controller.reset() - with preserve_expanded_rows( - tree_view=self._view, - role=self._model.UniqueRole - ): - with preserve_selection( - tree_view=self._view, - role=self._model.UniqueRole, - current_index=False - ): - kwargs = {"containers": containers} - # TODO do not touch view's inner attribute - if self._view._hierarchy_view: - kwargs["selected"] = self._view._selected - self._model.refresh(**kwargs) + self._view.refresh() def _on_show_timer(self): if self._show_counter < 3: @@ -171,17 +124,13 @@ class SceneInventoryWindow(QtWidgets.QDialog): self.refresh() def _on_hierarchy_view_change(self, enabled): - self._proxy.set_hierarchy_view(enabled) - self._model.set_hierarchy_view(enabled) + self._view.set_hierarchy_view(enabled) def _on_text_filter_change(self, text_filter): - if hasattr(self._proxy, "setFilterRegExp"): - self._proxy.setFilterRegExp(text_filter) - else: - self._proxy.setFilterRegularExpression(text_filter) + self._view.set_text_filter(text_filter) def _on_outdated_state_change(self): - self._proxy.set_filter_outdated( + self._view.set_filter_outdated( self._outdated_only_checkbox.isChecked() ) diff --git a/client/ayon_core/tools/utils/lib.py b/client/ayon_core/tools/utils/lib.py index d56b370d75..323b5c07e1 100644 --- a/client/ayon_core/tools/utils/lib.py +++ b/client/ayon_core/tools/utils/lib.py @@ -1,6 +1,7 @@ import os import sys import contextlib +import collections from functools import partial from qtpy import QtWidgets, QtCore, QtGui @@ -196,16 +197,16 @@ def get_openpype_qt_app(): return get_ayon_qt_app() -def iter_model_rows(model, column, include_root=False): +def iter_model_rows(model, column=0, include_root=False): """Iterate over all row indices in a model""" - indices = [QtCore.QModelIndex()] # start iteration at root - - for index in indices: + indexes_queue = collections.deque() + # start iteration at root + indexes_queue.append(QtCore.QModelIndex()) + while indexes_queue: + index = indexes_queue.popleft() # Add children to the iterations - child_rows = model.rowCount(index) - for child_row in range(child_rows): - child_index = model.index(child_row, column, index) - indices.append(child_index) + for child_row in range(model.rowCount(index)): + indexes_queue.append(model.index(child_row, column, index)) if not include_root and not index.isValid(): continue