[cuegui] Add dynamic plugin support with initial progress bar plugin (#1712)

- Implemented a dynamic plugin architecture under `cuegui/cueguiplugin/`, enabling developers to extend CueGUI with custom actions without modifying core code.
- Each plugin resides in its own subdirectory containing a `plugin.py` file that defines a `Plugin` class with metadata and context menu actions.
- Created `cuegui/cueguiplugin/loader.py` to auto-discover and load all available plugins at runtime, using `.cueguipluginrc.yaml` for enable/disable control.
- Integrated plugin action hooks into `MenuAction.py`, `JobMonitorTree.py`, and `CueJobMonitorTree.py` so that job context menus include plugin-defined `QAction`s dynamically.
- Added the first plugin: `cueprogbar`. This plugin introduces a "Show Progress Bar" context menu action for jobs, opening a visual widget to monitor job progress in real time.
- The progress bar widget displays frame state breakdowns and supports pause/unpause/kill operations.
- Right-click the bar to access control actions based on job state (e.g., Pause Job, Unpause Job, Kill Job).
- Left-click the bar to view a tooltip with the job name and frame state breakdown (SUCCEEDED, RUNNING, WAITING, DEPEND, DEAD, EATEN).
- Supports launching multiple progress bar windows for multiple selected jobs.
- Added `cueguiplugin/.cueguipluginrc.yaml`, `cueprogbar/config.yaml`, and plugin icons to `cuegui/setup.py`
- Ensures plugin system loads properly after `pip install cuegui/`

**Usage (`cueprogbar`):**

1. Open **Cuetopia** (Monitor Jobs) or **Cuecommander** (MonitorCue) from CueGUI.
2. Right-click on any job or jobs listed.
3. Select "Show Progress Bar" from the context menu.

This opens a visual widget per job with:

- Real-time progress bar (color-coded by frame state) for each line selected
- Labels with job info and progress summary
- Right-click actions to:
  - Pause / Unpause the job
  - Kill the job
- Left-click to view a breakdown of frame states (SUCCEEDED, RUNNING, WAITING, DEPEND, DEAD, EATEN)

This modular system enables future plugin additions without modifying the core GUI logic.

**Link the Issue(s) this Pull Request is related to.**
Add dynamic plugin system to CueGUI with Initial cueprogbar plugin #1711

Author: ramonfigueiredo

.gitignore

@@ -1,7 +1,9 @@
 *.idea/
+__pycache__
 *.pyc
 .DS_Store
 venv*/
+build/
 /build/
 /VERSION
 .scannerwork/

cuegui/cuegui/CueJobMonitorTree.py

@@ -42,6 +42,8 @@
 import cuegui.Style
 import cuegui.Utils
 
+from cuegui.cueguiplugin import loader as plugin_loader
+
 
 logger = cuegui.Logger.getLogger(__file__)
 Body = namedtuple("Body", "group_names, group_ids, job_names, job_ids")
@@ -580,6 +582,36 @@ def contextMenuEvent(self, e):
             menu.addSeparator()
             self.__menuActions.jobs().addAction(menu, "kill")
 
+            # Dynamically add plugin actions for right-clicked job(s)
+            plugins_by_type = {}
+            for job in selectedObjects:
+                for plugin in plugin_loader.load_plugins(job=job, parent=self):
+                    plugins_by_type[type(plugin)] = plugin
+
+            for plugin_type, plugin_instance in plugins_by_type.items():
+                if plugin_type.__name__ == "Plugin":
+                    # pylint: disable=protected-access
+                    label = plugin_instance._config.get("menu_label", "Unnamed Plugin")
+                    action = QtWidgets.QAction(label, self)
+
+                    def make_launch_all(ptype):
+                        def launch_all():
+                            for job in selectedObjects:
+                                plugin = ptype(job=job, parent=self)
+                                plugin.launch_subprocess()
+
+                        return launch_all
+
+                    action.triggered.connect(make_launch_all(plugin_type))
+                    menu.addSeparator()
+                    menu.addAction(action)
+                else:
+                    actions = plugin_instance.menuAction()
+                    if actions:
+                        menu.addSeparator()
+                        for action in actions:
+                            menu.addAction(action)
+
         menu.exec_(e.globalPos())
 
     def actionEatSelectedItems(self):

cuegui/cuegui/JobMonitorTree.py

@@ -41,6 +41,8 @@
 import cuegui.Style
 import cuegui.Utils
 
+from cuegui.cueguiplugin import loader as plugin_loader
+
 
 logger = cuegui.Logger.getLogger(__file__)
 
@@ -518,6 +520,38 @@ def contextMenuEvent(self, e):
         menu.addSeparator()
         self.__menuActions.jobs().addAction(menu, "kill")
 
+        # Dynamically add plugin actions for right-clicked job(s)
+        if __selectedObjects:
+            # Group plugins by type so we don’t load duplicates
+            plugins_by_type = {}
+            for job in __selectedObjects:
+                for plugin in plugin_loader.load_plugins(job=job, parent=self):
+                    plugins_by_type[type(plugin)] = plugin
+
+            for plugin_type, plugin_instance in plugins_by_type.items():
+                if plugin_type.__name__ == "Plugin":
+                    # Create single action that calls all subprocesses
+                    # pylint: disable=protected-access
+                    label = plugin_instance._config.get("menu_label", "Unnamed Plugin")
+                    action = QtWidgets.QAction(label, self)
+
+                    def make_launch_all(ptype):
+                        def launch_all():
+                            for job in __selectedObjects:
+                                plugin = ptype(job=job, parent=self)
+                                plugin.launch_subprocess()
+                        return launch_all
+
+                    action.triggered.connect(make_launch_all(plugin_type))
+                    menu.addSeparator()
+                    menu.addAction(action)
+                else:
+                    actions = plugin_instance.menuAction()
+                    if actions:
+                        menu.addSeparator()
+                        for action in actions:
+                            menu.addAction(action)
+
         menu.exec_(e.globalPos())
 
     def actionRemoveSelectedItems(self):

cuegui/cuegui/MenuActions.py

@@ -63,6 +63,8 @@
 import cuegui.UnbookDialog
 import cuegui.Utils
 
+from cuegui.cueguiplugin import loader as plugin_loader
+
 
 logger = cuegui.Logger.getLogger(__file__)
 
@@ -221,7 +223,49 @@ class JobActions(AbstractActions):
     """Actions for jobs."""
 
     def __init__(self, *args):
-        AbstractActions.__init__(self, *args)
+        """
+        Initialize JobActions and load associated plugins if a job source is available.
+
+        The plugin loading mechanism uses a double-callable pattern:
+        - `self._getSource` is expected to return a function
+        - that function is then called to retrieve the actual job object.
+
+        Plugins are loaded and initialized only if a valid job is retrieved.
+        """
+        super().__init__(*args)
+        self._pluginActions = []
+
+        # Attempt to retrieve the job object from the callable chain
+        source = None
+        try:
+            if callable(self._getSource):
+                maybe_func = self._getSource()
+                if callable(maybe_func):
+                    source = maybe_func()
+        except Exception as e:
+            # Optional: log if needed
+            logger.warning("Failed to resolve plugin source: %s", e)
+
+        # Load plugins only if source is valid
+        if source:
+            self._pluginActions = plugin_loader.load_plugins(job=source, parent=self._caller)
+
+    def addPluginActions(self, menu):
+        """
+        Add plugin-defined actions to the given context menu.
+
+        Args:
+            menu (QMenu): The Qt menu to which plugin actions will be appended.
+        """
+        for plugin in self._pluginActions:
+            actions = plugin.menuAction()
+            if not actions:
+                continue
+            if isinstance(actions, list):
+                for action in actions:
+                    menu.addAction(action)
+            else:
+                menu.addAction(actions)
 
     unmonitor_info = ["Unmonitor", "Unmonitor selected jobs", "eject"]
 

cuegui/cuegui/cueguiplugin/.cueguipluginrc.yaml

@@ -0,0 +1,39 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+# ------------------------------------------------------------------------------
+# CueGUI Plugin control configuration
+# ------------------------------------------------------------------------------
+# This file allows you to centrally manage which plugins are enabled or disabled.
+#
+# Plugin names must match the folder name inside `cueguiplugin/`.
+# Example:
+#   cueguiplugin/
+#   ├── cueprogbar/
+#   ├── mycustomplugin1/
+#   └── mycustomplugin2/
+#   ...
+#
+# This config is optional. If omitted, all plugins default to enabled unless
+# disabled in their own config.yaml.
+#
+# ------------------------------------------------------------------------------
+
+# Whitelist of plugins that are allowed to load
+# If this list is present, only these plugins will be loaded.
+enabled_plugins:
+  - cueprogbar       # Adds a visual floating job progress bar widget
+
+# List of plugins that should always be disabled, regardless of their own config.yaml
+disabled_plugins: []  # Currently no plugins are explicitly blocked

cuegui/cuegui/cueguiplugin/README.md

@@ -0,0 +1,163 @@
+# CueGUI Plugins
+
+This folder contains **optional plugins for CueGUI**. Plugins can add new menu actions, custom UI components, visualizations, and more - all without modifying CueGUI's core source code.
+
+## Contents
+- [Plugin structure](#plugin-structure)
+  - [Example of plugin folder structure](#example-of-plugin-folder-structure)
+- [Plugin loading](#plugin-loading)
+- [Adding a new plugin](#adding-a-new-plugin)
+- [List of plugins](#list-of-plugins)
+  - [1) cueprogbar](#1-cueprogbar)
+    - [How to use?](#how-to-use)
+    - [Standalone Mode (CLI)](#standalone-mode-cli)
+- [Notes](#notes)
+- [Tips](#tips)
+
+
+## Plugin structure
+
+Each plugin lives in its own subfolder under `cueguiplugin/`, and should contain the following:
+
+- `plugin.py`: Defines a `Plugin` class that extends `CueGuiPlugin`.
+- `config.yaml` (optional): Used to configure menu labels, icons, or behavior.
+- Additional supporting files (e.g., plugin code, icons, etc.).
+
+Note:
+- Plugin enablement is **only** managed via the `.cueguipluginrc.yaml` file.
+
+Go back to [Contents](#contents).
+
+### Example of plugin folder structure
+
+```
+cueguiplugin/
+├── README.md
+├── __init__.py                # Plugin interface definition
+├── loader.py                  # Plugin discovery and loading
+└── cueprogbar/                # Example plugin
+    ├── __init__.py
+    ├── __main__.py            # For standalone use (CLI)
+    ├── config.yaml            # Plugin-specific config (label, icon, etc.)
+    ├── darkmojo.py            # Custom dark UI palette
+    ├── images/
+    │   └── cueprogbar_icon.png
+    ├── main.py                # Widget logic
+    └── plugin.py              # Plugin class entrypoint
+```
+
+Go back to [Contents](#contents).
+
+## Plugin loading
+
+Plugins are dynamically loaded using `cueguiplugin/loader.py`, and automatically integrated into:
+- `MenuActions.py`
+- `JobMonitorTree.py` (Cuetopia)
+- `CueJobMonitorTree.py` (Cuecommander)
+
+### Available in both:
+- **Cuetopia**: Right-click on a job in the Monitor Jobs view.
+- **Cuecommander**: Right-click on a job in the Show/Job hierarchy view.
+
+There is no need to modify CueGUI itself. To add a plugin, just drop it into the `cueguiplugin/` directory. CueGUI will automatically discover and load it at runtime.
+
+Global plugin control is defined via `.cueguipluginrc.yaml` in this directory.
+
+Go back to [Contents](#contents).
+
+## Adding a new plugin
+
+1. Create a new folder inside `cueguiplugin/`, for example:
+
+```bash
+mkdir cueguiplugin/myplugin
+```
+
+2. Add a `plugin.py` with the following structure:
+
+```python
+from qtpy.QtWidgets import QAction
+from cuegui.cueguiplugin import CueGuiPlugin
+
+class Plugin(CueGuiPlugin):
+    def __init__(self, job, parent=None, config=None):
+        super().__init__(job=job, parent=parent, config=config)
+
+    def menuAction(self):
+        action = QAction("My Plugin Action", self._parent)
+        action.triggered.connect(self.run)
+        return action
+
+    def run(self):
+        print(f"Running plugin for job: {self._job.name()}")
+```
+
+3. Optionally, add a `config.yaml` to define:
+
+```yaml
+menu_label: My Plugin Action
+icon: images/my_icon.png
+```
+
+Go back to [Contents](#contents).
+
+## List of plugins
+
+### 1) `cueprogbar`
+
+The `cueprogbar` plugin adds a visual job progress bar for OpenCue jobs. It provides real-time color-coded frame status and basic job control.
+
+Go back to [Contents](#contents).
+
+#### How to use?
+
+1. Open **Cuetopia** (Monitor Jobs) or **Cuecommander** (MonitorCue) from CueGUI.
+2. Right-click on any job or jobs listed.
+3. Select "Show Progress Bar" from the context menu.
+
+This opens window(s) with:
+
+- Real-time progress bar (color-coded by frame state) for each line selected
+- Labels with job info and progress summary
+- Right-click actions to:
+  - Pause / Unpause the job
+  - Kill the job
+- Left-click to view a breakdown of frame states (SUCCEEDED, RUNNING, WAITING, DEPEND, DEAD, EATEN)
+
+Go back to [Contents](#contents).
+
+#### Standalone Mode (CLI)
+
+You can also launch the plugin directly:
+
+```bash
+cd OpenCue/
+python -m cuegui.cueguiplugin.cueprogbar <job_name>
+```
+
+Example:
+
+```bash
+python -m cuegui.cueguiplugin.cueprogbar testing-test_shot-my_render_job
+```
+
+This is useful for testing or displaying CueGUI plugins outside of CueGUI.
+
+Go back to [Contents](#contents).
+
+## Notes
+
+- All plugins must be Python 3 compatible.
+- Qt compatibility is maintained via qtpy (supports PySide2, PyQt5, PySide6, etc.).
+- Make sure plugins are lightweight and responsive - they run inside the CueGUI main process.
+
+Go back to [Contents](#contents).
+
+## Tips
+
+- You can enable or disable plugins centrally via `.cueguipluginrc.yaml`
+- Each plugin can still have its own `config.yaml` for UI customization (label, icon, etc.)
+- Use `darkmojo.py` if you want a consistent dark theme for all plugin UIs
+- Plugins are useful for extending CueGUI without having to fork or patch the core.
+
+Go back to [Contents](#contents).