Merge branch 'AcademySoftwareFoundation:master' into master

Author: lithorus

cuegui/cuegui/Constants.py

@@ -185,6 +185,17 @@ def __get_version_from_cmd(command):
 COLOR_USER_2 = QtGui.QColor(*__bg_colors[1])
 COLOR_USER_3 = QtGui.QColor(*__bg_colors[2])
 COLOR_USER_4 = QtGui.QColor(*__bg_colors[3])
+COLOR_USER_5 = QtGui.QColor(*__bg_colors[4])
+COLOR_USER_6 = QtGui.QColor(*__bg_colors[5])
+COLOR_USER_7 = QtGui.QColor(*__bg_colors[6])
+COLOR_USER_8 = QtGui.QColor(*__bg_colors[7])
+COLOR_USER_9 = QtGui.QColor(*__bg_colors[8])
+COLOR_USER_10 = QtGui.QColor(*__bg_colors[9])
+COLOR_USER_11 = QtGui.QColor(*__bg_colors[10])
+COLOR_USER_12 = QtGui.QColor(*__bg_colors[11])
+COLOR_USER_13 = QtGui.QColor(*__bg_colors[12])
+COLOR_USER_14 = QtGui.QColor(*__bg_colors[13])
+COLOR_USER_15 = QtGui.QColor(*__bg_colors[14])
 
 __frame_colors = __config.get('style.colors.frame_state')
 RGB_FRAME_STATE = {

cuegui/cuegui/DependDialog.py

@@ -39,7 +39,7 @@ def __init__(self, rpcOject, parent=None):
         self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
         self.setSizeGripEnabled(True)
 
-        self.resize(1000, 600)
+        self.resize(1200, 800)
 
         name = "Dependencies for "
         if cuegui.Utils.isJob(rpcOject):

cuegui/cuegui/DependMonitorTree.py

@@ -60,6 +60,11 @@ def __init__(self, parent, rpcObject):
 
         cuegui.AbstractTreeWidget.AbstractTreeWidget.__init__(self, parent)
 
+        # Set columns to auto-resize to content
+        header = self.header()
+        for col in range(self.columnCount()):
+            header.setSectionResizeMode(col, QtWidgets.QHeaderView.ResizeToContents)
+
         self.__menuActions = cuegui.MenuActions.MenuActions(
             self, self.updateSoon, self.selectedObjects)
 

cuegui/cuegui/DependWizard.py

@@ -388,7 +388,7 @@ def initializePage(self):
         self.setSubTitle("What type of dependency would you like %s to have?" % self.__msg())
 
         # it is not respecting or providing my size hints otherwise
-        self.wizard().setMinimumSize(500, 500)
+        self.wizard().setMinimumSize(1200, 800)
 
     # pylint: disable=missing-function-docstring
     def validatePage(self):

cuegui/cuegui/FrameMonitorTree.py

@@ -259,8 +259,9 @@ def tick(self):
 
         # Redrawing every even number of seconds to see the current frame
         # runtime, LLU and last log line changes. Every second was excessive.
-        if not self.ticksWithoutUpdate % 2:
-            self.redraw()
+        # Always redraw running frames regardless of update status
+        if self.__job and not self.ticksWithoutUpdate % 2:
+            self.redrawRunning()
 
     @staticmethod
     def getCores(frame, format_as_string=False):

cuegui/cuegui/JobMonitorTree.py

@@ -90,7 +90,7 @@ class JobMonitorTree(cuegui.AbstractTreeWidget.AbstractTreeWidget):
     """Tree widget to display a list of monitored jobs."""
 
     __loadMine = True
-    __groupDependent = True
+    __groupByMode = "Clear"  # Options: "Clear", "Dependent", "Show-Shot", "Show-Shot-Username"
     view_object = QtCore.Signal(object)
 
     def __init__(self, parent):
@@ -182,6 +182,8 @@ def __init__(self, parent):
         self.__dependentJobs = {}
         self._dependent_items = {}
         self.__reverseDependents = {}
+        self.__groupItems = {}  # For Show-Shot and Show-Shot-Username grouping
+        self.__groupExpansionState = {}  # Track expansion state of group items
         self.local_plugin_saved_values = {}
         # Used to build right click context menus
         self.__menuActions = cuegui.MenuActions.MenuActions(
@@ -274,12 +276,25 @@ def setLoadMine(self, value):
         @type  value: boolean or QtCore.Qt.Checked or QtCore.Qt.Unchecked"""
         self.__loadMine = (value is True or value == QtCore.Qt.Checked)
 
-    def setGroupDependent(self, value):
-        """Enables or disables the auto grouping of the dependent jobs
-        @param value: New groupDependent state
-        @type  value: boolean or QtCore.Qt.Checked or QtCore.Qt.Unchecked"""
-        self.__groupDependent = (value is True or value == QtCore.Qt.Checked)
-        self.updateRequest()
+    def setGroupBy(self, mode):
+        """Sets the grouping mode for jobs
+        @param mode: Grouping mode ("Clear", "Dependent", "Show-Shot", "Show-Shot-Username")
+        @type  mode: str"""
+        if mode in ["Clear", "Dependent", "Show-Shot", "Show-Shot-Username"]:
+            old_mode = self.__groupByMode
+            self.__groupByMode = mode
+
+            # If we have existing jobs, regroup them
+            if self._items and old_mode != mode:
+                current_jobs = {}
+                for proxy, item in list(self._items.items()):
+                    current_jobs[proxy] = item.rpcObject
+
+                # Process update with new grouping
+                if current_jobs:
+                    self._processUpdate(None, current_jobs)
+
+            self.updateRequest()
 
     def addJob(self, job, timestamp=None, loading_from_config=False):
         """Adds a job to the list. With locking"
@@ -294,7 +309,7 @@ def addJob(self, job, timestamp=None, loading_from_config=False):
         try:
             if newJobObj:
                 jobKey = cuegui.Utils.getObjectKey(newJobObj)
-                if not self.__groupDependent:
+                if self.__groupByMode == "Clear":
                     self.__load[jobKey] = newJobObj
                     self.__jobTimeLoaded[jobKey] = timestamp if timestamp else time.time()
                 else:
@@ -397,6 +412,7 @@ def removeAllItems(self):
                 del self.__jobTimeLoaded[proxy]
         self.__dependentJobs.clear()
         self.__reverseDependents.clear()
+        self.__groupItems.clear()
         cuegui.AbstractTreeWidget.AbstractTreeWidget.removeAllItems(self)
 
     def removeFinishedItems(self):
@@ -497,6 +513,20 @@ def contextMenuEvent(self, e):
         self.__menuActions.jobs().addAction(color_menu, "setUserColor2")
         self.__menuActions.jobs().addAction(color_menu, "setUserColor3")
         self.__menuActions.jobs().addAction(color_menu, "setUserColor4")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor5")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor6")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor7")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor8")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor9")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor10")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor11")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor12")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor13")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor14")
+        self.__menuActions.jobs().addAction(color_menu, "setUserColor15")
+        color_menu.addSeparator()
+        self.__menuActions.jobs().addAction(color_menu, "setUserCustomColor")
+        color_menu.addSeparator()
         self.__menuActions.jobs().addAction(color_menu, "clearUserColor")
         menu.addMenu(color_menu)
 
@@ -570,6 +600,62 @@ def actionSetUserColor(self, color):
                 self.__userColors[objectKey] = color
             item.setUserColor(color)
 
+    def actionSetUserCustomColor(self):
+        """Opens a dialog to set a custom RGB color for selected items"""
+        dialog = QtWidgets.QDialog(self)
+        dialog.setWindowTitle("Set Custom Color (RGB)")
+        dialog.setModal(True)
+
+        layout = QtWidgets.QFormLayout()
+
+        # Create spinboxes for RGB values
+        r_spinbox = QtWidgets.QSpinBox()
+        r_spinbox.setRange(0, 255)
+        r_spinbox.setValue(100)
+
+        g_spinbox = QtWidgets.QSpinBox()
+        g_spinbox.setRange(0, 255)
+        g_spinbox.setValue(100)
+
+        b_spinbox = QtWidgets.QSpinBox()
+        b_spinbox.setRange(0, 255)
+        b_spinbox.setValue(100)
+
+        # Color preview label
+        preview_label = QtWidgets.QLabel()
+        preview_label.setMinimumSize(200, 50)
+        preview_label.setFrameStyle(QtWidgets.QFrame.Box)
+        preview_label.setStyleSheet("background-color: rgb(100, 100, 100);")
+
+        def update_preview():
+            r = r_spinbox.value()
+            g = g_spinbox.value()
+            b = b_spinbox.value()
+            preview_label.setStyleSheet(f"background-color: rgb({r}, {g}, {b});")
+
+        r_spinbox.valueChanged.connect(update_preview)
+        g_spinbox.valueChanged.connect(update_preview)
+        b_spinbox.valueChanged.connect(update_preview)
+
+        layout.addRow("Red (0-255):", r_spinbox)
+        layout.addRow("Green (0-255):", g_spinbox)
+        layout.addRow("Blue (0-255):", b_spinbox)
+        layout.addRow("Preview:", preview_label)
+
+        # Buttons
+        button_box = QtWidgets.QDialogButtonBox(
+            QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
+        button_box.accepted.connect(dialog.accept)
+        button_box.rejected.connect(dialog.reject)
+        layout.addRow(button_box)
+
+        dialog.setLayout(layout)
+
+        if dialog.exec_() == QtWidgets.QDialog.Accepted:
+            # Create custom color from RGB values
+            custom_color = QtGui.QColor(r_spinbox.value(), g_spinbox.value(), b_spinbox.value())
+            self.actionSetUserColor(custom_color)
+
     def actionEatSelectedItems(self):
         """Eats all dead frames for selected jobs"""
         self.__menuActions.jobs().eatDead()
@@ -635,11 +721,15 @@ def _getUpdate(self):
                         monitored_proxies.remove(proxy)
 
             if monitored_proxies:
-                for job in opencue.api.getJobs(
-                        id=[proxyId.split('.')[-1] for proxyId in monitored_proxies],
-                        include_finished=True):
-                    objectKey = cuegui.Utils.getObjectKey(job)
-                    jobs[objectKey] = job
+                # Batch fetch jobs to improve performance
+                batch_size = 50  # Fetch in smaller batches to avoid timeouts
+                for i in range(0, len(monitored_proxies), batch_size):
+                    batch = monitored_proxies[i:i + batch_size]
+                    for job in opencue.api.getJobs(
+                            id=[proxyId.split('.')[-1] for proxyId in batch],
+                            include_finished=True):
+                        objectKey = cuegui.Utils.getObjectKey(job)
+                        jobs[objectKey] = job
 
         except opencue.exception.CueException as e:
             list(map(logger.warning, cuegui.Utils.exceptionOutput(e)))
@@ -672,16 +762,92 @@ def _processUpdate(self, work, rpcObjects):
             for item in self._dependent_items.values():
                 self.__jobTimeLoaded[cuegui.Utils.getObjectKey(item.rpcObject)] = item.created
 
+            # Save expansion state of current group items
+            for group_key, group_item in self.__groupItems.items():
+                self.__groupExpansionState[group_key] = group_item.isExpanded()
+
             self._items = {}
+            self.__groupItems = {}
             self.clear()
 
             for proxy, job in iteritems(rpcObjects):
-                self._items[proxy] = JobWidgetItem(job,
-                                                   self.invisibleRootItem(),
-                                                   self.__jobTimeLoaded.get(proxy, None))
-                if proxy in self.__userColors:
-                    self._items[proxy].setUserColor(self.__userColors[proxy])
-                if self.__groupDependent:
+                # Handle different grouping modes
+                if self.__groupByMode == "Clear":
+                    # No grouping - flat list
+                    self._items[proxy] = JobWidgetItem(job,
+                                                       self.invisibleRootItem(),
+                                                       self.__jobTimeLoaded.get(proxy, None))
+
+                elif self.__groupByMode == "Show-Shot":
+                    # Group by show-shot
+                    job_name = job.data.name
+                    parts = job_name.split("-")
+                    if len(parts) >= 2:
+                        show = parts[0]
+                        shot = parts[1]
+                        group_key = f"{show}-{shot}"
+
+                        # Create or get group parent item
+                        if group_key not in self.__groupItems:
+                            self.__groupItems[group_key] = GroupWidgetItem(
+                                group_key, self.invisibleRootItem(), "show-shot")
+                            # Restore expansion state or default to expanded
+                            is_expanded = self.__groupExpansionState.get(group_key, True)
+                            self.__groupItems[group_key].setExpanded(is_expanded)
+
+                        # Add job as child of group
+                        self._items[proxy] = JobWidgetItem(job,
+                                                          self.__groupItems[group_key],
+                                                          self.__jobTimeLoaded.get(proxy, None))
+                    else:
+                        # Can't parse show-shot, add to root
+                        self._items[proxy] = JobWidgetItem(job,
+                                                          self.invisibleRootItem(),
+                                                          self.__jobTimeLoaded.get(proxy, None))
+
+                elif self.__groupByMode == "Show-Shot-Username":
+                    # Group by show-shot-username
+                    job_name = job.data.name
+                    parts = job_name.split("-")
+                    if len(parts) >= 2:
+                        show = parts[0]
+                        shot = parts[1]
+                        # Extract username from the rest
+                        if len(parts) >= 3:
+                            rest = "-".join(parts[2:])
+                            username_parts = rest.split("_")
+                            if username_parts:
+                                username = username_parts[0]
+                            else:
+                                username = "unknown"
+                        else:
+                            username = "unknown"
+
+                        group_key = f"{show}-{shot}-{username}"
+
+                        # Create or get group parent item
+                        if group_key not in self.__groupItems:
+                            self.__groupItems[group_key] = GroupWidgetItem(
+                                group_key, self.invisibleRootItem(), "show-shot-username")
+                            # Restore expansion state or default to expanded
+                            is_expanded = self.__groupExpansionState.get(group_key, True)
+                            self.__groupItems[group_key].setExpanded(is_expanded)
+
+                        # Add job as child of group
+                        self._items[proxy] = JobWidgetItem(job,
+                                                          self.__groupItems[group_key],
+                                                          self.__jobTimeLoaded.get(proxy, None))
+                    else:
+                        # Can't parse show-shot-username, add to root
+                        self._items[proxy] = JobWidgetItem(job,
+                                                          self.invisibleRootItem(),
+                                                          self.__jobTimeLoaded.get(proxy, None))
+
+                elif self.__groupByMode == "Dependent":
+                    # Dependent mode - group by job dependencies
+                    self._items[proxy] = JobWidgetItem(job,
+                                                       self.invisibleRootItem(),
+                                                       self.__jobTimeLoaded.get(proxy, None))
                     dependent_jobs = self.__dependentJobs.get(proxy, [])
                     for djob in dependent_jobs:
                         item = JobWidgetItem(djob,
@@ -693,6 +859,9 @@ def _processUpdate(self, work, rpcObjects):
                             self._dependent_items[dkey].setUserColor(
                                            self.__userColors[dkey])
 
+                if proxy in self.__userColors:
+                    self._items[proxy].setUserColor(self.__userColors[proxy])
+
             self.verticalScrollBar().setRange(scrolled, len(rpcObjects.keys()) - scrolled)
             list(map(lambda key: self._items[key].setSelected(True),
                      [key for key in selectedKeys if key in self._items]))
@@ -797,3 +966,41 @@ def data(self, col, role):
             return self.rpcObject.isPaused()
 
         return cuegui.Constants.QVARIANT_NULL
+
+
+class GroupWidgetItem(QtWidgets.QTreeWidgetItem):
+    """Represents a group parent item in the JobMonitorTree."""
+
+    def __init__(self, group_name, parent, group_type):
+        """Initialize a group widget item.
+        @param group_name: The name of the group (e.g., "show-shot" or "show-shot-username")
+        @param parent: The parent item
+        @param group_type: Type of grouping ("show-shot" or "show-shot-username")
+        """
+        QtWidgets.QTreeWidgetItem.__init__(self, parent)
+        self.group_name = group_name
+        self.group_type = group_type
+        self.setText(0, group_name)
+
+        # Set bold font for group headers
+        font = QtGui.QFont()
+        font.setBold(True)
+        self.setFont(0, font)
+
+        # Make group headers non-selectable
+        self.setFlags(self.flags() & ~QtCore.Qt.ItemIsSelectable)
+
+    def data(self, col, role):
+        """Return data for the given column and role."""
+        if role == QtCore.Qt.DisplayRole:
+            if col == 0:
+                return self.group_name
+            return ""
+
+        if role == QtCore.Qt.FontRole and col == 0:
+            font = QtGui.QFont()
+            font.setBold(True)
+            return font
+
+        # Let the parent handle all other roles (including selection colors)
+        return QtWidgets.QTreeWidgetItem.data(self, col, role)