pymodaq_plugins_oceaninsight 5.3.0__tar.gz

pymodaq_plugins_oceaninsight-5.3.0/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

pymodaq_plugins_oceaninsight-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_oceaninsight-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_oceaninsight-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_oceaninsight-5.3.0/.gitignore

@@ -0,0 +1,116 @@
+# Compiled python modules.
+*.pyc
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# pycharm
+.idea/
+.idea/*
+
+*yacctab.py
+*lextab.py
+

pymodaq_plugins_oceaninsight-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_oceaninsight-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_oceaninsight-5.3.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

pymodaq_plugins_oceaninsight-5.3.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: pymodaq_plugins_oceaninsight
+Version: 5.3.0
+Summary: Set of PyMoDAQ plugins for OceanInsight (OceanOptics) spectrometers
+Project-URL: Homepage, https://pymodaq.cnrs.fr
+Project-URL: Documentation , https://pymodaq.cnrs.fr
+Project-URL: Repository , https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight
+Author-email: Sébastien Weber <sebastien.weber@cemes.fr>
+Maintainer-email: Sébastien Weber <sebastien.weber@cemes.fr>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+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
+Requires-Dist: pythonnet
+Requires-Dist: seabreeze
+Description-Content-Type: text/x-rst
+
+pymodaq_plugins_oceaninsight (Ocean Insight (Optics) Spectrometers)
+###################################################################
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_oceaninsight.svg
+   :target: https://pypi.org/project/pymodaq_plugins_oceaninsight/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight/workflows/Upload%20Python%20Package/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight
+
+PyMoDAQ plugin for OceanInsight (OceanOptics) spectrometers
+
+
+Authors
+=======
+
+* Sebastien J. Weber
+* Nicolas Tappy
+* Arnaud Meyer
+
+Instruments
+===========
+Below is the list of instruments included in this plugin.
+Url: https://www.oceaninsight.com/products/spectrometers/
+
+Viewer1D
+++++++++
+
+* **Omnidriver**: Control of Spectrometer using the Omnidriver library (should be installed)
+* **Seabreeze** : If the Omnidriver library is not available, a plugin implementation based on seabreeze is provided: https://python-seabreeze.readthedocs.io/en/latest/index.html

pymodaq_plugins_oceaninsight-5.3.0/README.rst

@@ -0,0 +1,34 @@
+pymodaq_plugins_oceaninsight (Ocean Insight (Optics) Spectrometers)
+###################################################################
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_oceaninsight.svg
+   :target: https://pypi.org/project/pymodaq_plugins_oceaninsight/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight/workflows/Upload%20Python%20Package/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight
+
+PyMoDAQ plugin for OceanInsight (OceanOptics) spectrometers
+
+
+Authors
+=======
+
+* Sebastien J. Weber
+* Nicolas Tappy
+* Arnaud Meyer
+
+Instruments
+===========
+Below is the list of instruments included in this plugin.
+Url: https://www.oceaninsight.com/products/spectrometers/
+
+Viewer1D
+++++++++
+
+* **Omnidriver**: Control of Spectrometer using the Omnidriver library (should be installed)
+* **Seabreeze** : If the Omnidriver library is not available, a plugin implementation based on seabreeze is provided: https://python-seabreeze.readthedocs.io/en/latest/index.html

pymodaq_plugins_oceaninsight-5.3.0/hatch_build.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+from pymodaq_utils.resources.hatch_build_plugins import update_metadata_from_toml
+
+here = Path(__file__).absolute().parent
+
+
+class PluginInfoTomlHook(MetadataHookInterface):
+    def update(self, metadata: dict) -> None:
+        update_metadata_from_toml(metadata, here)

pymodaq_plugins_oceaninsight-5.3.0/pyproject.toml

@@ -0,0 +1,65 @@
+[features]  # defines the plugin features contained into this plugin
+instruments = true  # true if plugin contains instrument classes (else false, notice the lowercase for toml files)
+extensions = false  # true if plugins contains dashboard extensions
+models = false  # true if plugins contains models of the extensions (PID, optimizers, data mixer, sequencer, ...)
+h5exporters = false  # true if plugin contains custom h5 file exporters
+scanners = false  # true if plugin contains custom scan layout (daq_scan extensions)
+
+[urls]
+package-url = "https://github.com/PyMoDAQ/pymodaq_plugins_oceaninsight"
+
+[project]
+name = "pymodaq_plugins_oceaninsight"
+description = "Set of PyMoDAQ plugins for OceanInsight (OceanOptics) spectrometers"
+dependencies = [
+    "pymodaq>=5.3.2",
+    "pymodaq_utils>=5.3.1",
+    "pymodaq_gui>=5.3.0",
+    "pymodaq_data>=5.3.0",
+    "pythonnet",
+    "seabreeze",
+]
+
+authors = [
+    {name = "Sébastien Weber", email = "sebastien.weber@cemes.fr"},
+]
+maintainers = [
+    {name = "Sébastien Weber", email = "sebastien.weber@cemes.fr"},
+]
+
+# nottodo: leave everything below as is!
+
+dynamic = ["version", "urls", "entry-points"]
+readme = "README.rst"
+license = { file="LICENSE" }
+requires-python = ">=3.10"
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+    "Topic :: Scientific/Engineering :: Visualization",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: User Interfaces",
+]
+
+[build-system]
+requires = [
+    "hatchling>=1.9.0",
+    "hatch-vcs", "toml",
+    "pymodaq_utils>=0.0.6",
+]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata.hooks.custom]
+
+[tool.hatch.version]
+source = "vcs"
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/__init__.py

@@ -0,0 +1,12 @@
+from pymodaq_utils.utils import get_version, PackageNotFoundError
+from pathlib import Path
+from pymodaq.utils.logger import set_logger  # to be imported by other modules.
+
+from .utils import Config
+config = Config()
+
+
+try:
+    __version__ = get_version(__package__)
+except PackageNotFoundError:
+    __version__ = '0.0.0dev'

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_move_plugins/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from .. import set_logger
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/__init__.py

@@ -0,0 +1,3 @@
+
+
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_0D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer0D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer1D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Omnidriver.py

@@ -0,0 +1,177 @@
+from qtpy import QtWidgets
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+
+import numpy as np
+from collections import OrderedDict
+from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
+from pymodaq.utils.data import DataFromPlugins, Axis, DataToExport
+import sys
+import clr
+from easydict import EasyDict as edict
+
+from pymodaq_plugins_oceaninsight.utils import Config
+
+plugin_config = Config()
+
+omnidriver_path = plugin_config('omnidriver_path')
+try:
+    sys.path.append(omnidriver_path)
+    clr.AddReference("NETOmniDriver-NET40")
+    import OmniDriver as omnidriver
+
+except:
+    omnidriver = None
+
+
+class DAQ_1DViewer_Omnidriver(DAQ_Viewer_base):
+    """PyMoDAQ plugin controlling spectrometers from OceanOptics and using their OmniDriver wrapper ('NETOmniDriver-NET40')
+    The wrapper is interfaced using the clr package and then importing Omnidriver as a standart python package
+    https://oceanoptics.com/api/omnidriver/index.html?overview-summary.html
+
+    The plugin enables the discovery of any connected usb spectrometers and can control them in parallel. It extracts the
+    calibrated wavelength and will export datas that will be plotted with respect to this wavelengths vector.
+
+    Used methods from the wrapper:
+    ------------------------------
+     setIntegrationTime
+     getIntegrationTime
+
+    See Also
+    --------
+    utility_classes.DAQ_Viewer_base
+    """
+
+    params = comon_parameters + [
+        {'title': 'N spectrometers:', 'name': 'Nspectrometers', 'type': 'int', 'value': 0,
+         'default': 0, 'min': 0, 'readonly': True},
+        {'title': 'Spectrometers:', 'name': 'spectrometers', 'type': 'group', 'children': []},
+        ]
+
+    hardware_averaging = True
+
+    def ini_attributes(self):
+
+        self.controller: omnidriver.NETWrapper = None
+        self.spectro_names = [] #contains the spectro name as returned from the wrapper
+        self.spectro_id = [] # contains the spectro id as set by the ini_detector method and equal to the Parameter name
+
+
+    def commit_settings(self, param):
+        """
+        """
+        if param.name() == 'exposure_time':
+            ind_spectro = self.spectro_id.index(param.parent().name())
+            self.controller.setIntegrationTime(ind_spectro, param.value() * 1000)
+
+            param.setValue(self.controller.getIntegrationTime(ind_spectro) / 1000)
+
+    def ini_detector(self, controller=None):
+        """
+            Initialisation procedure of the detector updating the status dictionnary.
+
+            See Also
+            --------
+            set_Mock_data, daq_utils.ThreadCommand
+        """
+        self.ini_detector_init(controller, None)
+
+        if self.is_master:
+            self.controller = omnidriver.NETWrapper()
+
+            N = self.controller.openAllSpectrometers()
+            self.settings.child('Nspectrometers').setValue(N)
+            self.spectro_names = []
+            self.spectro_id = []
+
+            data_init = DataToExport('Spectro')
+
+            for ind_spectro in range(N):
+                name = self.controller.getName(ind_spectro)
+                self.spectro_names.append(name)
+                self.spectro_id.append('spectro{:d}'.format(ind_spectro))
+
+                exp_max = self.controller.getMaximumIntegrationTime(ind_spectro)
+                exp_min = self.controller.getMinimumIntegrationTime(ind_spectro)
+                exp = self.controller.getIntegrationTime(ind_spectro) / 1000
+                wavelengths = self.get_xaxis(ind_spectro)
+
+                data_init.append(DataFromPlugins(name=name, data=[np.zeros_like(wavelengths)],
+                                                 dim='Data1D',
+                                                 x_axis=Axis(data=wavelengths, label='Wavelength',
+                                                             units='nm')))
+
+                for ind in range(2): #this is to take into account that adding it once doen't work (see pyqtgraph Parameter...)
+                    try:
+                        self.settings.child('spectrometers').addChild(
+                            {'title': name,'name': 'spectro{:d}'.format(ind_spectro),
+                             'type': 'group', 'children':[
+                                {'title': 'grab spectrum:','name': 'grab', 'type': 'bool',
+                                 'value': True},
+                            {'title': 'Exposure time (ms):','name': 'exposure_time', 'type': 'int',
+                             'value': int(exp), 'min': int(exp_min/1000), 'max': int(exp_max/1000)},
+
+                            ]
+                             })
+                    except:
+                        pass
+
+                QtWidgets.QApplication.processEvents()
+
+            #init viewers
+
+            if N == 0:
+                raise Exception('No detected hardware')
+            self.dte_signal_temp.emit(data_init)
+
+        initialized = True
+        info = 'Ocean Insight Spectrometers initialized'
+        return info, initialized
+
+    def get_xaxis(self, ind_spectro):
+        wavelengths_chelou = self.controller.getWavelengths(ind_spectro)
+        wavelengths = np.array([wavelengths_chelou[ind] for ind in range(len(wavelengths_chelou))])
+
+        return wavelengths
+
+    def close(self):
+        """
+        """
+        if self.controller is not None:
+            self.controller.closeAllSpectrometers()
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """
+
+        """
+        try:
+            dte = DataToExport('Spectro')
+            for ind_spectro in range(len(self.spectro_names)):
+                if self.settings.child('spectrometers', 'spectro{:d}'.format(ind_spectro), 'grab').value():
+                    self.controller.setScansToAverage(ind_spectro, Naverage)
+                    data_chelou = self.controller.getSpectrum(ind_spectro)
+                    data_array = np.array([data_chelou[ind] for ind in range(len(data_chelou))])
+                    dte.append(
+                      DataFromPlugins(name=self.spectro_names[ind_spectro],
+                                      data=[data_array], dim='Data1D',
+                                      axes=[Axis('wavelength',
+                                                 units='m',
+                                                 data=self.get_xaxis(ind_spectro)
+                                                      * 1e-9)]))
+                    QtWidgets.QApplication.processEvents()
+
+            self.dte_signal.emit(dte)
+
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), "log"]))
+
+    def stop(self):
+        """
+
+        """
+        for ind_spec, name in enumerate(self.spectro_names):
+            self.controller.stopAveraging(ind_spec)
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_1D/daq_1Dviewer_Seabreeze.py

@@ -0,0 +1,164 @@
+import numpy as np
+from easydict import EasyDict as edict
+from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
+from pymodaq.utils.data import DataFromPlugins, Axis, DataToExport
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+from timeit import timeit
+
+# explicitly request cseabreeze
+import seabreeze
+seabreeze.use('cseabreeze')
+from seabreeze.spectrometers import Spectrometer, list_devices
+
+
+class DAQ_1DViewer_Seabreeze(DAQ_Viewer_base):
+    """PyMoDAQ 1DViewer class for devices supported by the Seabreeze library."""
+
+    # Upon initialisation
+    devices = list_devices()
+
+    # Supports pseudo hardware-averaging
+    hardware_averaging = True
+
+    # Adjustable parameters
+    params = comon_parameters + [
+        {'title': 'Device:', 'name': 'device', 'type': 'list', 'limits': devices},
+        {'title': 'Integration (ms):', 'name': 'integration', 'type': 'float', 'value': 1.0},
+        {'title': 'Advanced:', 'name': 'advanced', 'type': 'group', 'children': [
+            {'title': 'Serial Number:', 'name': 'serial_number', 'type': 'str', 'value': "", 'readonly': True},
+            {'title': 'Non Linearity correction:', 'name': 'correct_non_linearity', 'type': 'bool', 'value': False},
+            {'title': 'Max Intensity', 'name': 'max_intensity', 'type': "float", 'value': 65535, 'readonly': True},
+            {'title': 'Pixels:', 'name': 'pixels', 'type': 'int', 'value': 2048, 'readonly': True},
+            {'title': 'Dark Channels:', 'name': 'dark_channels', 'type': 'str', 'value': '', 'readonly': True},
+            {'title': 'Readout Time (ms)', 'name': 'readout_time', 'type': 'float', 'value': 666, 'readonly': True},
+        ]}
+    ]
+
+    def ini_attributes(self):
+        self.controller: Spectrometer = None
+
+    def commit_settings(self, param):
+        """
+        """
+        if param.name() == "integration":
+            self.controller.integration_time_micros(param.value() * 1000)
+            # There is no way to get feedback from the spectrometer on the currently set integration time
+        # elif ...
+        ##
+
+    def ini_detector(self, controller=None):
+        """Detector communication initialization
+
+        Parameters
+        ----------
+        controller: (object) custom object of a PyMoDAQ plugin (Slave case). None if only one detector by controller (Master case)
+
+        Returns
+        -------
+        self.status (edict): with initialization status: three fields:
+            * info (str)
+            * controller (object) initialized controller
+            *initialized: (bool): False if initialization failed otherwise True
+        """
+        if self.is_master:
+            # From what I understand this will just get the spectro currently selected in the list
+            dvc = self.settings['device']
+            self.controller = Spectrometer(dvc)
+            #self.controller.open()
+
+        else:
+            self.controller = controller
+
+        # Oceanoptics spectrometers (at least the ones i Know) have fixed axis
+        # get index of inactive pixels
+        dark_indices = self.controller.f.spectrometer.get_electric_dark_pixel_indices()
+        self.settings.child('advanced').child('dark_channels').setValue(", ".join([str(x) for x in dark_indices]))
+        # get the x_axis
+        data_x_axis = self.controller.wavelengths()  # Way to get the x axis
+        # keep range without dark pixels
+        x_indices = np.arange(data_x_axis.shape[0])
+        self.valid_range = np.setdiff1d(x_indices, dark_indices)
+        data_x_axis = data_x_axis[self.valid_range]
+        # generate PyMoDAQ axis
+        self.x_axis = Axis(data=data_x_axis * 1e-9, label='wavelength', units='m', index=0)
+
+        # Get the name
+        specname = f"Ocean Insight {self.controller.model}"
+
+        # initialize viewers pannel with the future type of data
+
+        self.data_grabed_signal_temp.emit([
+            DataFromPlugins(name=specname,
+                            data=[np.zeros_like(data_x_axis)],
+                            dim='Data1D',
+                            labels=['Intensity'],
+                            axes=[self.x_axis]), ])
+
+
+        # Update the parameters
+        # Here we need to do a few things. Get the integration time limits and set it in the settings
+        tlimits = np.array(self.controller.integration_time_micros_limits) / 1000
+        self.settings.child('integration').setLimits(tlimits)
+        # Here we need to update the advanced parameters
+        advanced_settings = self.settings.child('advanced')
+        sn = self.controller.serial_number
+        advanced_settings.child('serial_number').setValue(sn)
+        # non linearity coefficients
+        nlc_feat = self.controller.f.nonlinearity_coefficients
+        if nlc_feat is not None and not any(np.isnan(nlc_feat.get_nonlinearity_coefficients())):
+            advanced_settings.child('correct_non_linearity').setValue(True)
+        else:
+            advanced_settings.child('correct_non_linearity').setValue(False)
+            advanced_settings.child('correct_non_linearity').setOpts(enabled=False)
+
+        # measure the readout time
+        Nperf = 200
+        self.settings.child('integration').setValue(tlimits[0])  # Update the parameter value to the lower limit
+        self.controller.integration_time_micros(tlimits[0]*1000)  # Set the readout time to lower limit
+        perf = timeit(lambda: self.controller.intensities(), number=Nperf)  # time the execution of code in [s]
+        self.settings.child('advanced').child('readout_time').setValue(1000*perf/Nperf)  # set the settings
+
+        ##############################
+
+        info = f"Initialized {specname} spectrometer"
+        initialized = True
+        return info, initialized
+
+    def close(self):
+        """
+        Terminate the communication protocol
+        """
+        if self.controller is not None:
+            self.controller.close()
+
+    def grab_data(self, Naverage = 1, **kwargs):
+        """
+        Parameters
+        ----------
+        Naverage: (int) Number of hardware averaging
+        kwargs: (dict) of others optionals arguments
+        """
+        nlc = self.settings.child('advanced').child('correct_non_linearity').value()
+        #c0 = self.settings.child('advanced').child('dark_channels').value()
+
+        # synchrone version (blocking function)
+        # Pseudo-hardware-averaging
+        if Naverage > 1:
+            data = [self.controller.intensities(correct_nonlinearity=nlc)[self.valid_range]
+                    for i in range(Naverage)]
+            data = np.array(data)
+            data = data.mean(0)
+        # Otherwise normal single-acquisition
+        else:
+            data = self.controller.intensities(correct_nonlinearity=nlc)[self.valid_range]
+
+        self.dte_signal.emit(DataToExport('Spectro', data=[
+            DataFromPlugins(name='oceanseabreeze', data=[data], dim='Data1D',
+                            labels=['spectrum'], axes=[self.x_axis.copy()])]))
+
+    def stop(self):
+        pass
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_2D/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer2D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/daq_viewer_plugins/plugins_ND/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from pymodaq.utils.logger import set_logger
+logger = set_logger('viewerND_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/resources/config_template.toml

@@ -0,0 +1,3 @@
+title = "this is the configuration file of the plugin OceanInsight"
+
+omnidriver_path = 'C:\\Program Files\\Ocean Optics\\OmniDriver\\OOI_HOME'

pymodaq_plugins_oceaninsight-5.3.0/src/pymodaq_plugins_oceaninsight/utils.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 31/08/2023
+
+@author: Sebastien Weber
+"""
+from pathlib import Path
+
+from pymodaq.utils.config import BaseConfig, USER
+
+
+class Config(BaseConfig):
+    """Main class to deal with configuration values for this plugin"""
+    config_template_path = Path(__file__).parent.joinpath('resources/config_template.toml')
+    config_name = f"config_{__package__.split('pymodaq_plugins_')[1]}"

pymodaq_plugins_oceaninsight-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