pymodaq_plugins_utils 5.0.7__tar.gz → 5.3.0__tar.gz

pymodaq_plugins_utils-5.3.0/.github/workflows/compatibility.yml

@@ -0,0 +1,15 @@
+# Everything is defined once in PyMoDAQ/pymodaq_plugins_template (reusable-*.yml). The template is never released, so the ref after @ is its 5.3.x branch.
+name: Compatibility with pymodaq (latest release)
+
+on:
+  pull_request:
+  push:
+    branches: [main, master, '[0-9]*.x']
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  compatibility:
+    uses: PyMoDAQ/pymodaq_plugins_template/.github/workflows/reusable-compatibility.yml@5.3.x

pymodaq_plugins_utils-5.3.0/.github/workflows/python-publish.yml

@@ -0,0 +1,11 @@
+# Everything is defined once in PyMoDAQ/pymodaq_plugins_template (reusable-*.yml). The template is never released, so the ref after @ is its 5.3.x branch.
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    uses: PyMoDAQ/pymodaq_plugins_template/.github/workflows/reusable-publish.yml@5.3.x
+    secrets: inherit

pymodaq_plugins_utils-5.3.0/.github/workflows/tests.yml

@@ -0,0 +1,8 @@
+# Everything is defined once in PyMoDAQ/pymodaq_plugins_template (reusable-*.yml). The template is never released, so the ref after @ is its 5.3.x branch.
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  tests:
+    uses: PyMoDAQ/pymodaq_plugins_template/.github/workflows/reusable-tests.yml@5.3.x

pymodaq_plugins_utils-5.3.0/AGENTS.md

@@ -0,0 +1,206 @@
+# AGENTS.md
+
+Guidance for AI coding assistants (and humans) building on **PyMoDAQ 5.3.x** from this template.
+PyMoDAQ is a Qt framework that drives lab experiments: hardware is added through small *plugins*, and PyMoDAQ
+provides the GUI, threading, data model, scans and HDF5 saving. Python 3.10 to 3.13.
+
+This repository is a plugin package named `pymodaq_plugins_<name>`. Rename everything that still says `template`
+before publishing.
+
+## 1. Choose what to build
+
+Prefer the first option that fits:
+
+1. **Instrument plugin** (`daq_move_plugins/`, `daq_viewer_plugins/`): a new device must appear in the Dashboard.
+2. **Dashboard extension** (`extensions/`, class derived from `CustomExt`): a workflow that uses instruments
+   (scans, feedback, custom panels, logging). It runs inside the Dashboard and reuses its stable mechanisms for
+   instruments: the experiment manager and the state manager (how a Dashboard setup is described, loaded and
+   restored; the word "preset" is obsolete), the module manager, control-module threading, shared controllers,
+   saving. **If the application drives instruments, build a `CustomExt`, not a `CustomApp`.**
+3. **Standalone app** (`app/`, class derived from `CustomApp`): only when the application needs **no
+   instruments** (data viewer, analysis, h5 browsing, configuration tools).
+4. A plain script, for a one-off sequence that does not need a GUI.
+
+A **model** (section 6) is not a separate option: it tailors an existing extension (PID, optimizers, data mixer,
+sequencer) to your experiment.
+
+## 2. Workflow
+
+```bash
+pip install -e .                 # editable install of this plugin, from the repository root
+check_plugin                     # static report on this package (hardware not needed)
+check_plugin --fail-on todo -v   # also list every unfinished TODO
+pytest                           # template tests (package structure, plugin checks, behaviour against a fake controller)
+```
+
+Installing PyMoDAQ itself is a separate matter. A plugin only needs the released packages (`pymodaq`,
+`pymodaq_utils`, `pymodaq_data`, `pymodaq_gui`, installed as dependencies). If you also have to modify them, work in a
+clone of the PyMoDAQ repository and install the four packages in editable mode with the script at its root, never with
+`pip install -e .` inside each package (the script handles the order and the options):
+
+```bash
+python install-packages.py -d                 # editable + dev extras, from the PyMoDAQ repository root
+python install-packages.py -d -qt pyside6     # choose the Qt backend (pyqt5, pyqt6 or pyside6)
+```
+
+Do not consider a task finished until `check_plugin` and `pytest` pass. Do not invent PyMoDAQ APIs: if a method
+or attribute is not in the base classes (`DAQ_Move_base`, `DAQ_Viewer_base`, `CustomExt`) or in an existing
+plugin, look it up in the installed `pymodaq` package instead of guessing.
+
+## 3. Instrument plugins
+
+File and class names must match: `daq_move_<Name>.py` holds `DAQ_Move_<Name>`; `daq_<N>Dviewer_<Name>.py` holds
+`DAQ_<N>DViewer_<Name>` (N = 0, 1, 2 or N). Each file ends with `if __name__ == '__main__': main(__file__)`.
+
+**Actuator** (`DAQ_Move_base`). Override at least, in the order of the template (the order in which to develop them),
+`ini_attributes`, `ini_stage`, `close`, `get_actuator_value`, `move_abs`, `move_rel`, `move_home`, `stop_motion`,
+`commit_settings`.
+
+- `ini_stage(controller=None)` returns `(info: str, initialized: bool)`. If `self.is_master`, create the controller;
+  otherwise store the `controller` passed in (several axes share one controller).
+- Class attributes: `is_multiaxes`, `_axis_names`, `_controller_units`, `_epsilons`,
+  `data_actuator_type = DataActuatorType.DataActuator`, optionally `ui_type` and `has_encoder`. Always write the
+  `data_actuator_type` line: the default of the base class is `DataActuatorType.float`, a backcompatibility mode where
+  `move_abs`/`move_rel` receive a plain float (already in the axis unit) and `get_actuator_value` returns one. PyMoDAQ
+  guards that case, but do not use it in new code.
+- `params` = list of dicts + `comon_parameters_fun(is_multiaxes, axis_names=..., epsilon=...)`.
+- Positions are `DataActuator` objects with **units** (`units=self.axis_unit`); use `check_bound`,
+  `set_position_with_scaling` and `get_position_with_scaling` as in the template.
+
+**Detector** (`DAQ_Viewer_base`). Override at least, in the order of the template, `ini_attributes`, `ini_detector`,
+`close`, `grab_data`, `stop`, `commit_settings`.
+
+- `ini_detector(controller=None)` returns `(info, initialized)`, same master/slave logic.
+- `params = comon_parameters + [...]`.
+- Data leaves the plugin as `DataToExport` containing `DataFromPlugins` (with `dim='Data0D'|'Data1D'|'Data2D'|'DataND'`,
+  `labels`, `axes=[Axis(...)]`) emitted through `self.dte_signal` (grab) or `self.dte_signal_temp` (live preview).
+
+**Rules that matter**
+
+- Plugin code runs in a worker thread. **Never create or touch Qt widgets** from it. Report progress with
+  `self.emit_status(ThreadCommand('Update_Status', ['message']))`.
+- Do not block for long inside `grab_data` or a move; use the asynchronous pattern shown in the template and the
+  polling that PyMoDAQ already does (`epsilon`).
+- Always release the hardware in `close()`, only if `self.is_master and self.controller is not None` (the init may have
+  failed before the controller existed). Leave actuators in a safe state on error.
+- Settings are `pyqtgraph` Parameter dicts (`{'title', 'name', 'type', 'value', ...}`). React to changes in
+  `commit_settings(param)` by `param.name()`.
+- Units are `pint`-based. Give every actuator value and every `Axis` a unit; mismatches raise `DataUnitError`.
+  What you send to a controller must be expressed in the controller units: use `value.value(self.axis_unit)` in
+  `move_abs` / `move_rel`, never `value.value()` (the magnitude in whatever unit the `DataActuator` carries, so 1 cm
+  would be sent as 1.0 to a controller in mm). `axis_unit` is the unit of the current axis, `axis_units` the list/dict
+  of all the axes of a multiaxes controller.
+- Hardware access code goes in `hardware/`, behind a small wrapper class. This lets the plugin be tested with a
+  mock controller and keeps the plugin file readable.
+- Defaults live in `resources/config_template.toml`, not in the code. Read configuration values through
+  `GlobalConfig` from `pymodaq_utils.config`: a singleton that wraps the `Config` objects of all packages, e.g.
+  `GlobalConfig()('gui', 'style', 'theme')`. Do not parse the toml files yourself, and do not instantiate a `Config`
+  class directly (deprecated): PyMoDAQ registers the `Config` of `<your_package>/utils.py` in `GlobalConfig` when it
+  discovers the plugin, under the package name without `pymodaq_plugins_`.
+
+**Testing behaviour without hardware.** `pymodaq.utils.plugin_testing` (shipped with PyMoDAQ >= 5.3.2) drives a plugin the way PyMoDAQ does, without a GUI:
+`make_actuator` / `make_detector` (instantiate and call `ini_stage` / `ini_detector`), `move_abs_and_wait`,
+`move_rel_and_wait`, `move_home_and_wait`, `grab_and_wait` (return the final position or the `DataToExport`, and fail
+on a timeout) and `assert_units`. `tests/example_mock_plugins.py` shows a fake controller and the smallest actuator,
+multi-axes actuator and 1D detector; `tests/test_plugin_behaviour.py` shows the tests to copy. Write the vendor
+communication behind a wrapper class in `hardware/`, write a fake with the same public methods, and run your real
+plugin class against it (monkeypatch the wrapper class). Targets reach the plugin in the axis unit, as in PyMoDAQ.
+
+These tests only check your side of the PyMoDAQ contract (return types, units, signals, shared controller, `close`)
+against a fake that encodes what you believe the driver does. They say nothing about the device: timing, error replies,
+real ranges and units. A passing run is not a hardware validation: never state that a plugin works on an instrument
+that was not used, say what was tested on the real device and what only against a fake.
+
+**Legacy patterns to avoid** (older tutorials and models still produce them; `check_plugin` flags several):
+`stage_names` (use `_axis_names`), `_epsilon` (use `_epsilons`), `data_actuator_type = float` (use
+`DataActuatorType.DataActuator`), the group names `multiaxes` and `multi_status` (now `controller` and
+`controller_status`), importing `CustomExt` from `pymodaq.extensions.custom_ext` (use `pymodaq.utils.custom_ext`),
+and the deprecated `CustomApp` / `CustomExt` hooks `setup_docks` and `setup_menu` (use `setup_docks_and_widgets` and
+`setup_menus_and_toolbars`).
+
+## 4. Dashboard extensions (`CustomExt`)
+
+- Entry point group `pymodaq.extensions` in `pyproject.toml`; each module in `extensions/` defines
+  `EXTENSION_NAME` (menu label), `CLASS_NAME` (class name) and a class derived from `CustomExt`.
+- Import: `from pymodaq.utils.custom_ext import CustomExt`.
+- A plugin extension follows exactly the pattern of the core extensions (`daq_scan`, `sequencer`, `ramping`, data
+  mixer). The only difference is `EXTENSION_NAME` and `CLASS_NAME`, which the Dashboard needs to recognise it.
+- **`_quit_fun(self) -> bool` must be overridden and return `True`** (return `False`, after telling the user, while
+  the extension is running). The base implementation returns `None`, which prevents closing.
+- **`main()` pattern** (to run the extension alone, same as the core ones):
+
+  ```python
+  def main():
+      import sys
+      from pymodaq_gui.qt_utils import mkQApp
+      from pymodaq.dashboard import load_dashboard_with_arguments
+      from pymodaq.utils.gui_utils.loader_utils import create_extension
+
+      app = mkQApp('My Extension')
+      win, dashboard, _ = load_dashboard_with_arguments(show_dashboard=False, load_extension=False)
+      win.mainwindow.setVisible(False)
+      win_ext, ext = create_extension(dashboard, MyExtension, show_extension=True)
+      sys.exit(app.exec())
+  ```
+
+  `load_dashboard_with_arguments` reads the command line (`-x EXPERIMENT_NAME`, `-s STATE_NAME`).
+  `create_extension` already shows the window: do not call `win_ext.show()` again, and do not use `create_load_dashboard`
+  here.
+- Long-running work (a scan, a sequence, a ramp) goes in an `ExtensionWorker` subclass run in a thread, started and
+  stopped from the extension's workflow actions, as in `sequencer.py` and `ramping.py`.
+- `__init__(self, parent: DockArea, dashboard)`: call `super().__init__(parent, dashboard)`, then `self.setup_ui()`.
+- **Experiment and state belong to the Dashboard.** The *experiment* is the list of instruments (actuators and
+  detectors) the Dashboard manages and controls; the *state* is the state of that experiment, mostly the values of the
+  instruments' settings and of the Dashboard's actuators. An extension must use the managers it gets through its
+  `dashboard` argument, as `self.experiment_manager` and `self.state_manager`, and never create its own, nor its own
+  save/load of instrument configurations. Override `do_things_after_experiment_set(experiment_name, show_dashboard)`
+  to react when an experiment is set (the base class refreshes `self.modules_manager` there), and use
+  `create_dashboard_toolbar(...)` to expose the experiment and state actions in your extension.
+- The Dashboard's instruments are reached through `self.modules_manager`. This `ModulesManager` is created anew for
+  each extension by the base class `__init__`, so that every extension can handle different instruments: never share
+  it between extensions, replace it, or reuse the Dashboard's one. Do not create control modules yourself inside an
+  extension, and do not talk to the hardware directly.
+- Implement the lifecycle, in the order `setup_ui` calls it: `setup_docks_and_widgets`, `setup_menus_and_toolbars`
+  (only creates the menus and toolbars), `setup_actions` (creates the actions and can put them in those menus and
+  toolbars with `add_action(..., menu=..., toolbar=...)`), `connect_things`, then `value_changed`, `quit_fun`. `setup_docks` and `setup_menu` are deprecated. The GUI thread runs
+  your code; react to module signals, never poll or sleep.
+
+## 5. Standalone apps (`CustomApp`)
+
+Only when no instrument is needed. Same (non-deprecated) lifecycle as above, `parent` is a `DockArea` or `QMainWindow`, and
+`main()` creates the app with `mkQApp`. If instruments become necessary, move the logic to a `CustomExt`.
+
+## 6. Models of the extensions (`models/`)
+
+Four Dashboard extensions delegate the part that depends on your experiment to a model class that your package
+provides: PID (`PIDModelGeneric`), Bayesian and Adaptive optimizers (`OptimizerModelGeneric` or `OptimizerModelDefault`),
+DataMixer (`DataMixerModel`) and the Sequencer (`ChoiceModelBase`). Write a model, not an extension, when one of these
+extensions already does the job and only the conversion of the measurements or of the outputs is specific.
+
+- Set `models = true` in `[features]`; entry points are generated only then (`pymodaq.models`).
+- Create the `models/` folder at the root of the package, one model per module; the module name is the name shown in
+  the extension. The model is the class defined in the module that derives from the base class of the extension. It may
+  derive from your own intermediate class, but PID and DataMixer only accepted a direct subclass of the generic base
+  before the release that follows 5.3.3, so derive directly from it if you must support older releases. The Sequencer
+  is the exception: it does not look at base classes, you register each choice model with
+  `@ChoiceModelFactory.register_choice()`.
+- The template ships no model on purpose. Start from the working examples of
+  [`pymodaq_plugins_mockexamples`](https://github.com/PyMoDAQ/pymodaq_plugins_mockexamples) (`PIDModelBeamSteering`,
+  `PIDModelMockHeater`, `BayesianModelMock`, `DataMixerModelFit`; for the Sequencer, the choice models of
+  `pymodaq/extensions/sequencer/models`) and from the page "Models of the extensions" of the PyMoDAQ
+  documentation, which lists the methods to implement for each kind. Test a model with the mock actuators and
+  detectors of that package.
+- Do not use the old `pid_models` flag nor the word "preset" in new code: a model script that opens the Dashboard loads
+  an experiment file.
+
+## 7. Done checklist
+
+- [ ] Names (package, files, classes) match and the `template` placeholders are gone.
+- [ ] The `[features]` flags at the top of `pyproject.toml` match the folders you use (`instruments`, `extensions`,
+      `models`...): entry points are generated only for the features set to `true` (`check_plugin` warns, PMQ109).
+- [ ] `check_plugin` passes; no `NotImplementedError` or `TODO` left in the files you wrote.
+- [ ] Units set on all actuator values and axes; safe behaviour in `close()` and on errors.
+- [ ] Tests added for new behaviour using a mock controller (no real hardware in CI).
+- [ ] Docstring of each plugin class states: compatible devices, what was tested, PyMoDAQ and OS versions,
+      drivers to install.
+- [ ] `README.rst` updated; target PyMoDAQ version stated.

pymodaq_plugins_utils-5.3.0/CLAUDE.md

@@ -0,0 +1,3 @@
+# CLAUDE.md
+
+Read and follow [AGENTS.md](AGENTS.md): it holds all the guidance for AI coding assistants working in this repository.

{pymodaq_plugins_utils-5.0.7 → pymodaq_plugins_utils-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymodaq_plugins_utils
-Version: 5.0.7
+Version: 5.3.0
 Summary: Set of utility methods and classes to interact with instruments
 Project-URL: Homepage, https://pymodaq.cnrs.fr
 Project-URL: Documentation , https://pymodaq.cnrs.fr
@@ -43,7 +43,10 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.8
-Requires-Dist: pymodaq>=5.0.0
+Requires-Dist: pymodaq-data>=5.3.0
+Requires-Dist: pymodaq-gui>=5.3.0
+Requires-Dist: pymodaq-utils>=5.3.1
+Requires-Dist: pymodaq>=5.3.2
 Provides-Extra: camera
 Requires-Dist: opencv-python; extra == 'camera'
 Requires-Dist: pylablib; extra == 'camera'

{pymodaq_plugins_utils-5.0.7 → pymodaq_plugins_utils-5.3.0}/pyproject.toml

@@ -23,7 +23,10 @@ camera = [
 name = "pymodaq_plugins_utils"
 description = 'Set of utility methods and classes to interact with instruments'
 dependencies = [
-    "pymodaq>=5.0.0",
+    "pymodaq>=5.3.2",
+    "pymodaq_utils>=5.3.1",
+    "pymodaq_gui>=5.3.0",
+    "pymodaq_data>=5.3.0",
     #todo: list here all dependencies your package may have
 ]
 

{pymodaq_plugins_utils-5.0.7 → pymodaq_plugins_utils-5.3.0}/src/pymodaq_plugins_utils/hardware/serial_ports.py

@@ -6,13 +6,13 @@ not installed, all functions return empty lists and a warning is logged.
 
 Typical usage in a plugin::
 
-    from pymodaq_utils.hardware.serial_ports import list_resources
+    from pymodaq_plugins_utils.hardware.serial_ports import list_resources
 
     ports = list_resources()  # e.g. ['/dev/ttyUSB0', 'COM3']
 
 After hot-plugging a device, refresh the cache with::
 
-    from pymodaq_utils.hardware.serial_ports import invalidate_cache
+    from pymodaq_plugins_utils.hardware.serial_ports import invalidate_cache
     invalidate_cache()
 """
 import pymodaq_utils.logger as logger_module

{pymodaq_plugins_utils-5.0.7 → pymodaq_plugins_utils-5.3.0}/src/pymodaq_plugins_utils/hardware/visa.py

@@ -6,13 +6,13 @@ VISA backend is found, all functions return empty lists and a warning is logged.
 
 Typical usage in a plugin::
 
-    from pymodaq_utils.hardware.visa import list_serial_resources
+    from pymodaq_plugins_utils.hardware.visa import list_serial_resources
 
     ports = list_serial_resources()  # e.g. ['ASRL/dev/ttyUSB0::INSTR']
 
 After hot-plugging a device, refresh the cache with::
 
-    from pymodaq_utils.hardware.visa import invalidate_cache
+    from pymodaq_plugins_utils.hardware.visa import invalidate_cache
     invalidate_cache()
 """
 import pymodaq_utils.logger as logger_module

pymodaq_plugins_utils-5.3.0/tests/test_plugin_package_structure.py

@@ -0,0 +1,28 @@
+"""Acceptance tests of the plugin, provided by PyMoDAQ (from version 5.3.2).
+
+They check the package structure, the entry points, the naming of the instrument modules and classes, the mandatory
+attributes and methods of the plugin classes, and apply the static rules of PyMoDAQ on the sources
+(see https://pymodaq.cnrs.fr/en/latest/developer_folder/instrument_plugins.html#testing-your-plugin).
+
+The unfinished parts of the plugin (TODO comments, placeholders) are listed but do not fail the tests, set
+``fail_on = 'todo'`` before a release. Add your own tests, specific to your instruments, in other files.
+"""
+import importlib.util
+
+import pytest
+
+try:
+    available = importlib.util.find_spec('pymodaq.utils.plugin_testing') is not None
+except ModuleNotFoundError:  # pymodaq is not installed
+    available = False
+if not available:
+    pytest.skip('The plugin acceptance checks need PyMoDAQ >= 5.3.2', allow_module_level=True)
+
+from pymodaq.utils.plugin_testing import PluginPackageChecks
+
+
+class TestPlugin(PluginPackageChecks):
+    # package_name = 'pymodaq_plugins_xxxx'  # only if it cannot be found from the pyproject.toml and the package folder
+    fail_on = 'error'  # 'error', 'warning' or 'todo' (also fail on the unfinished parts)
+    strict_imports = False  # True: also fail when a module cannot be imported (missing dependency or driver); the
+    # modules of an instrument whose driver cannot be installed on the CI runner are then skipped, not failed

pymodaq_plugins_utils-5.0.7/.github/workflows/Test.yml

@@ -1,10 +0,0 @@
-name: 'Tests'
-
-on: [push]
-
-jobs:
-  call_workflow:
-    uses: ./.github/workflows/Testbase.yml
-    with:
-      python: '3.12'
-      qt5: 'pyside6'

pymodaq_plugins_utils-5.0.7/.github/workflows/Testbase.yml

@@ -1,44 +0,0 @@
-name: Base
-
-on:
-    workflow_call:
-      inputs:
-        python:
-          required: true
-          type: string
-        qt5:
-          required: true
-          type: string
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    env:
-      DISPLAY: ':99.0'
-      QT_DEBUG_PLUGINS: 1
-    steps:
-      - name: Set up Python ${{ inputs.python }}
-        uses: actions/checkout@v7.0.1
-      - name: Install dependencies
-        uses: actions/setup-python@v7.0.0
-        with:
-          python-version: ${{ inputs.python }}
-      - name: Install package
-        run: |
-          sudo apt install libxkbcommon-x11-0 libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xinerama0 libxcb-xfixes0 x11-utils
-          python -m pip install --upgrade pip
-          export QT_DEBUG_PLUGINS=1
-          pip install flake8 pytest pytest-cov pytest-qt pytest-xdist pytest-xvfb setuptools wheel numpy h5py ${{ inputs.qt5 }} toml
-          pip install pymodaq pyqt5
-          pip install -e .
-      - name: create local pymodaq folder and setting permissions
-        run: |
-          sudo mkdir /etc/.pymodaq
-          sudo chmod uo+rw /etc/.pymodaq
-      - name: Linting with flake8
-        run: |
-          # stop the build if there are Python syntax errors or undefined names
-          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics --exclude=src/pymodaq/resources/QtDesigner_Ressources,docs
-      - name: Test with pytest
-        run: |
-          pytest -n auto

pymodaq_plugins_utils-5.0.7/.github/workflows/compatibility.yml

@@ -1,78 +0,0 @@
-name: Compatibility with pymodaq (latest release)
-
-on:
-  workflow_call:
-  
-  pull_request:
-
-  push:
-    branches:
-    - '*'
-
-concurrency:
-  # github.workflow: name of the workflow
-  # github.event.pull_request.number || github.ref: pull request number or branch name if not a pull request
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  # Cancel in-progress runs when a new workflow with the same group name is triggered
-  cancel-in-progress: true
-  
-jobs:
-  tests:
-    continue-on-error: true
-    strategy:
-      fail-fast: false
-      matrix:
-        os: ["ubuntu-latest", "windows-latest"]
-        python-version: ["3.9", "3.10", "3.11", "3.12"]
-        qt-backend: ["pyqt5", "pyqt6", "pyside6"]
-    runs-on: ${{ matrix.os }}
-    env:
-      DISPLAY: ':99'
-      QT_DEBUG_PLUGINS: 1
-
-    steps:
-      - name: Set project name environment variable
-        run: |
-          echo "plugin_name=$(echo '${{ github.repository }}' | cut -d'/' -f2)" >> $GITHUB_ENV
-
-      - name: Checkout the repo
-        uses: actions/checkout@v7.0.1
- 
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v7.0.0
-        with:
-          python-version: ${{ matrix.python-version }}
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install flake8 pytest pytest-cov pytest-qt pytest-xvfb pytest-xdist setuptools wheel numpy h5py pymodaq ${{ matrix.qt-backend }}
-          pip install -e .    
-      
-      # Create folder and set permissions on Ubuntu
-      - name: Create local pymodaq folder setup env (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt update
-          sudo apt install -y libxkbcommon-x11-0 libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-cursor0 libxcb-randr0 libxcb-render-util0 libxcb-xinerama0 libxcb-xfixes0 x11-utils libgl1 libegl1
-          export QT_DEBUG_PLUGINS=1
-          sudo mkdir -p /etc/.pymodaq
-          sudo chmod uo+rw /etc/.pymodaq
-      - name: Exporting debug variables (Windows)
-        if: runner.os == 'Windows'
-        run: |
-          set QT_DEBUG_PLUGINS=1
-
-      - name: Compatibility tests with ${{ matrix.os }} ${{ matrix.python-version }} ${{ matrix.qt-backend}}
-        run: |
-          pytest -vv -n 1 -k "test_compatibility"          
-
-      - name: Upload compatibility report
-        if: failure()
-        uses: actions/upload-artifact@v7.0.1
-        with:
-          name:  
-          path: 'import_report_tests_${{ env.plugin_name }}_None.txt'
-          if-no-files-found: error 
-    
-  

pymodaq_plugins_utils-5.0.7/.github/workflows/python-publish.yml

@@ -1,40 +0,0 @@
-# This workflow will upload a Python Package using Twine when a release is created
-# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
-
-name: Upload Python Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  deploy:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v7.0.1
-    - name: Set up Python
-      uses: actions/setup-python@v7.0.0
-      with:
-        python-version: '3.13'
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install hatch hatchling toml twine
-    - name: Get history and tags for SCM versioning to work
-      run: |
-        git branch
-        git fetch --prune --unshallow
-        git fetch --depth=1 origin +refs/tags/*:refs/tags/*
-        hatch version
-    - name: Build
-      run: hatch build
-    - name: Check the build
-      run: twine check dist/*
-    - name: publish
-      env:
-        HATCH_INDEX_USER: ${{ secrets.PYPI_USERNAME }}
-        HATCH_INDEX_AUTH: ${{ secrets.PYPI_PASSWORD }}
-      run: |
-        hatch publish

pymodaq_plugins_utils-5.0.7/.github/workflows/updater.yml

@@ -1,24 +0,0 @@
-name: GitHub Actions Version Updater
-
-# Controls when the action will run.
-on:
-  workflow_dispatch:
-  schedule:
-    # Automatically run at 00:00 on day-of-month 5.
-    - cron:  '0 0 5 * *'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v7.0.1
-        with:
-          # [Required] Access token with `workflow` scope.
-          token: ${{ secrets.WORKFLOW_SECRET }}
-
-      - name: Run GitHub Actions Version Updater
-        uses: saadmk11/github-actions-version-updater@v0.9.0
-        with:
-          # [Required] Access token with `workflow` scope.
-          token: ${{ secrets.WORKFLOW_SECRET }}

pymodaq_plugins_utils-5.0.7/tests/test_plugin_package_structure.py

@@ -1,111 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 17/10/2023
-
-@author: Sebastien Weber
-"""
-import pytest
-from pathlib import Path
-import importlib
-import pkgutil
-from collections.abc import Iterable
-
-from pymodaq_data import Q_, Unit
-
-
-MANDATORY_MOVE_METHODS = ['ini_attributes', 'get_actuator_value', 'close', 'commit_settings',
-                          'ini_stage', 'move_abs', 'move_home', 'move_rel', 'stop_motion']
-MANDATORY_VIEWER_METHODS = ['ini_attributes', 'grab_data', 'close', 'commit_settings',
-                          'ini_detector', ]
-
-
-def get_package_name():
-    here = Path(__file__).parent
-    package_name = here.parent.stem
-    return package_name
-
-def get_move_plugins():
-    pkg_name = get_package_name()
-    try:
-        move_mod = importlib.import_module(f'{pkg_name}.daq_move_plugins')
-        plugin_list = [mod for mod in [mod[1] for mod in
-                                       pkgutil.iter_modules([str(move_mod.path.parent)])]
-                       if 'daq_move_' in mod]
-    except ModuleNotFoundError:
-        plugin_list = []
-        move_mod = None
-    return plugin_list, move_mod
-
-
-def get_viewer_plugins(dim='0D'):
-    pkg_name = get_package_name()
-    try:
-        viewer_mod = importlib.import_module(f'{pkg_name}.daq_viewer_plugins.plugins_{dim}')
-
-        plugin_list = [mod for mod in [mod[1] for mod in
-                                       pkgutil.iter_modules([str(viewer_mod.path.parent)])]
-                       if f'daq_{dim}viewer_' in mod]
-    except ModuleNotFoundError:
-        plugin_list = []
-        viewer_mod = None
-    return plugin_list, viewer_mod
-
-
-def test_package_name_ok():
-    assert 'pymodaq_plugins_' in get_package_name()[0:16]
-
-
-def test_imports():
-    pkg_name = get_package_name()
-    mod = importlib.import_module(pkg_name)
-    assert hasattr(mod, 'config')
-    assert hasattr(mod, '__version__')
-
-
-def test_move_inst_plugins_name():
-    plugin_list, move_mod = get_move_plugins()
-    for plug in plugin_list:
-        name = plug.split('daq_move_')[1]
-        assert hasattr(getattr(move_mod, plug), f'DAQ_Move_{name}')
-
-
-def test_move_has_mandatory_methods():
-    plugin_list, move_mod = get_move_plugins()
-    for plug in plugin_list:
-        name = plug.split('daq_move_')[1]
-        klass = getattr(getattr(move_mod, plug), f'DAQ_Move_{name}')
-        for meth in MANDATORY_MOVE_METHODS:
-            assert hasattr(klass, meth)
-
-
-def test_move_has_correct_units():
-    plugin_list, move_mod = get_move_plugins()
-    for plug in plugin_list:
-        name = plug.split('daq_move_')[1]
-        klass = getattr(getattr(move_mod, plug), f'DAQ_Move_{name}')
-        if not isinstance(klass._controller_units, list):
-            if isinstance(klass._controller_units, dict):
-                units = list(klass._controller_units.values())
-            elif isinstance(klass._controller_units, str):
-                units = [klass._controller_units]
-            else:
-                raise TypeError(f'{klass._controller_units} is an invalid type')
-        else:
-            units = klass._controller_units
-        for unit in units:
-            Unit(unit)  # check if the unit is known from pint
-
-
-@pytest.mark.parametrize('dim', ('0D', '1D', '2D', 'ND'))
-def test_viewer_has_mandatory_methods(dim):
-    plugin_list, mod = get_viewer_plugins(dim)
-    for plug in plugin_list:
-        name = plug.split(f'daq_{dim}viewer_')[1]
-        try:
-            module = importlib.import_module(f'.{plug}', mod.__package__)
-        except Exception:
-            break
-        klass = getattr(module, f'DAQ_{dim}Viewer_{name}')
-        for meth in MANDATORY_VIEWER_METHODS:
-            assert hasattr(klass, meth)
-