pymodaq_plugins_utils 5.0.2__tar.gz

pymodaq_plugins_utils-5.0.2/.gitattributes

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

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

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

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

@@ -0,0 +1,44 @@
+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@v5.0.0
+      - name: Install dependencies
+        uses: actions/setup-python@v6.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 -k "not test_compatibility"

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

@@ -0,0 +1,78 @@
+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@v5.0.0
+ 
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6.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@v4.6.2
+        with:
+          name:  
+          path: 'import_report_tests_${{ env.plugin_name }}_None.txt'
+          if-no-files-found: error 
+    
+  

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

@@ -0,0 +1,40 @@
+# 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@v5.0.0
+    - name: Set up Python
+      uses: actions/setup-python@v6.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.2/.github/workflows/updater.yml

@@ -0,0 +1,24 @@
+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@v5.0.0
+        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.2/.gitignore

@@ -0,0 +1,116 @@
+# Compiled python modules.
+*.pyc
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+_version.py
+
+*.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_utils-5.0.2/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_utils-5.0.2/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: pymodaq_plugins_utils
+Version: 5.0.2
+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
+Project-URL: Repository , https://github.com/PyMoDAQ/pymodaq_plugins_utils
+Author-email: Weber Sebastien <sebastien.weber@cemes.fr>
+Maintainer-email: Weber Sebastien <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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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.8
+Requires-Dist: pymodaq>=5.0.0
+Provides-Extra: serial
+Requires-Dist: pyvisa; extra == 'serial'
+Description-Content-Type: text/x-rst
+
+pymodaq_plugins_utils
+#####################
+
+.. the following must be adapted to your developed package, links to pypi, github  description...
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_utils.svg
+   :target: https://pypi.org/project/pymodaq_plugins_utils/
+   :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_utils/workflows/Upload%20Python%20Package/badge.svg
+   :target: https://github.com/PyMoDAQ/pymodaq_plugins_utils
+   :alt: Publication Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_utils/actions/workflows/Test.yml/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_utils/actions/workflows/Test.yml
+
+
+
+Authors
+=======
+
+* Sebastien J. Weber (sebastien.weber@cemes.fr)
+* Other author (myotheremail@xxx.org)
+
+.. if needed use this field
+
+    Contributors
+    ============
+
+    * First Contributor
+    * Other Contributors
+
+.. if needed use this field
+
+  Depending on the plugin type, delete/complete the fields below
+
+
+Utilities
+=========
+
+* pysvisa stuff
+* CameraBasePyLabLib: Base plugin class inheriting from DAQ_Viewer_base but implementing ROI management, binning,
+  the use of buffers through the pylablib package implementation. Mostly for (S)CMOS camera

pymodaq_plugins_utils-5.0.2/README.rst

@@ -0,0 +1,47 @@
+pymodaq_plugins_utils
+#####################
+
+.. the following must be adapted to your developed package, links to pypi, github  description...
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_utils.svg
+   :target: https://pypi.org/project/pymodaq_plugins_utils/
+   :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_utils/workflows/Upload%20Python%20Package/badge.svg
+   :target: https://github.com/PyMoDAQ/pymodaq_plugins_utils
+   :alt: Publication Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_utils/actions/workflows/Test.yml/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_utils/actions/workflows/Test.yml
+
+
+
+Authors
+=======
+
+* Sebastien J. Weber (sebastien.weber@cemes.fr)
+* Other author (myotheremail@xxx.org)
+
+.. if needed use this field
+
+    Contributors
+    ============
+
+    * First Contributor
+    * Other Contributors
+
+.. if needed use this field
+
+  Depending on the plugin type, delete/complete the fields below
+
+
+Utilities
+=========
+
+* pysvisa stuff
+* CameraBasePyLabLib: Base plugin class inheriting from DAQ_Viewer_base but implementing ROI management, binning,
+  the use of buffers through the pylablib package implementation. Mostly for (S)CMOS camera

pymodaq_plugins_utils-5.0.2/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_utils-5.0.2/pyproject.toml

@@ -0,0 +1,71 @@
+[features]  # defines the plugin features contained into this plugin
+instruments = false  # 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 pid models
+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_utils'
+
+
+
+[project]
+name = "pymodaq_plugins_utils"
+description = 'Set of utility methods and classes to interact with instruments'
+dependencies = [
+    "pymodaq>=5.0.0",
+    #todo: list here all dependencies your package may have
+]
+
+authors = [
+    {name = "Weber Sebastien", email = "sebastien.weber@cemes.fr"},
+    #todo: list here all authors of your plugin
+]
+maintainers = [
+    {name = "Weber Sebastien", email = "sebastien.weber@cemes.fr"},
+    #todo: list here all maintainers of your plugin
+]
+
+# nottodo: leave everything below as is!
+
+dynamic = ["version", "urls", "entry-points"]
+readme = "README.rst"
+license = { file="LICENSE" }
+requires-python = ">=3.8"
+
+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.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+    "Topic :: Scientific/Engineering :: Visualization",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: User Interfaces",
+]
+
+[project.optional-dependencies]
+serial = [
+    "pyvisa",
+]
+
+
+[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_utils-5.0.2/src/pymodaq_plugins_utils/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from .utils import Config
+from pymodaq_utils.utils import get_version, PackageNotFoundError
+from pymodaq_utils.logger import set_logger, get_module_name
+
+config = Config()
+try:
+    __version__ = get_version(__package__)
+except PackageNotFoundError:
+    __version__ = '0.0.0dev'
+
+
+

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/exporters/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/extensions/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/extensions/custom_extension_template.py

@@ -0,0 +1,140 @@
+from qtpy import QtWidgets
+
+from pymodaq_gui import utils as gutils
+from pymodaq_utils.config import Config, ConfigError
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq.utils.config import get_set_preset_path
+from pymodaq.extensions.utils import CustomExt
+
+
+# todo: replace here *pymodaq_plugins_utils* by your plugin package name
+from pymodaq_plugins_template.utils import Config as PluginConfig
+
+logger = set_logger(get_module_name(__file__))
+
+main_config = Config()
+plugin_config = PluginConfig()
+
+# todo: modify this as you wish
+EXTENSION_NAME = 'MY_EXTENSION_NAME'  # the name that will be displayed in the extension list in the
+# dashboard
+CLASS_NAME = 'CustomExtensionTemplate'  # this should be the name of your class defined below
+
+
+# todo: modify the name of this class to reflect its application and change the name in the main
+# method at the end of the script
+class CustomExtensionTemplate(CustomExt):
+
+    # todo: if you wish to create custom Parameter and corresponding widgets. These will be
+    # automatically added as children of self.settings. Morevover, the self.settings_tree will
+    # render the widgets in a Qtree. If you wish to see it in your app, add is into a Dock
+    params = []
+
+    def __init__(self, parent: gutils.DockArea, dashboard):
+        super().__init__(parent, dashboard)
+
+        # info: in an extension, if you want to interact with ControlModules you have to use the
+        # object: self.modules_manager which is a ModulesManager instance from the dashboard
+
+        self.setup_ui()
+
+    def setup_docks(self):
+        """Mandatory method to be subclassed to setup the docks layout
+
+        Examples
+        --------
+        >>>self.docks['ADock'] = gutils.Dock('ADock name')
+        >>>self.dockarea.addDock(self.docks['ADock'])
+        >>>self.docks['AnotherDock'] = gutils.Dock('AnotherDock name')
+        >>>self.dockarea.addDock(self.docks['AnotherDock'''], 'bottom', self.docks['ADock'])
+
+        See Also
+        --------
+        pyqtgraph.dockarea.Dock
+        """
+        # todo: create docks and add them here to hold your widgets
+        # reminder, the attribute self.settings_tree will  render the widgets in a Qtree.
+        # If you wish to see it in your app, add is into a Dock
+        raise NotImplementedError
+
+    def setup_actions(self):
+        """Method where to create actions to be subclassed. Mandatory
+
+        Examples
+        --------
+        >>> self.add_action('quit', 'Quit', 'close2', "Quit program")
+        >>> self.add_action('grab', 'Grab', 'camera', "Grab from camera", checkable=True)
+        >>> self.add_action('load', 'Load', 'Open', "Load target file (.h5, .png, .jpg) or data from camera"
+            , checkable=False)
+        >>> self.add_action('save', 'Save', 'SaveAs', "Save current data", checkable=False)
+
+        See Also
+        --------
+        ActionManager.add_action
+        """
+        raise NotImplementedError(f'You have to define actions here')
+
+    def connect_things(self):
+        """Connect actions and/or other widgets signal to methods"""
+        raise NotImplementedError
+
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
+        """Non mandatory method to be subclassed in order to create a menubar
+
+        create menu for actions contained into the self._actions, for instance:
+
+        Examples
+        --------
+        >>>file_menu = menubar.addMenu('File')
+        >>>self.affect_to('load', file_menu)
+        >>>self.affect_to('save', file_menu)
+
+        >>>file_menu.addSeparator()
+        >>>self.affect_to('quit', file_menu)
+
+        See Also
+        --------
+        pymodaq.utils.managers.action_manager.ActionManager
+        """
+        # todo create and populate menu using actions defined above in self.setup_actions
+        pass
+
+    def value_changed(self, param):
+        """ Actions to perform when one of the param's value in self.settings is changed from the
+        user interface
+
+        For instance:
+        if param.name() == 'do_something':
+            if param.value():
+                print('Do something')
+                self.settings.child('main_settings', 'something_done').setValue(False)
+
+        Parameters
+        ----------
+        param: (Parameter) the parameter whose value just changed
+        """
+        pass
+
+
+def main():
+    from pymodaq.utils.gui_utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+    from pymodaq.utils.messenger import messagebox
+
+    app = mkQApp(EXTENSION_NAME)
+    try:
+        preset_file_name = plugin_config('presets', f'preset_for_{CLASS_NAME.lower()}')
+        load_dashboard_with_preset(preset_file_name, EXTENSION_NAME)
+        app.exec()
+
+    except ConfigError as e:
+        messagebox(f'No entry with name f"preset_for_{CLASS_NAME.lower()}" has been configured'
+                   f'in the plugin config file. The toml entry should be:\n'
+                   f'[presets]'
+                   f"preset_for_{CLASS_NAME.lower()} = {'a name for an existing preset'}"
+                   )
+
+
+if __name__ == '__main__':
+    main()

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/hardware/camera_base_pylablib.py

@@ -0,0 +1,398 @@
+import cv2
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
+try:
+    from pymodaq_gui.plotting.items.roi import RoiInfo  # pymodaq > 5.1.x
+except ImportError:
+    from pymodaq_gui.plotting.utils.plot_utils import RoiInfo
+
+from pymodaq.utils.data import DataFromPlugins, Axis
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+
+from qtpy import QtWidgets, QtCore
+import numpy as np
+from time import perf_counter
+
+
+cam_params = [
+    {'title': 'Camera name:', 'name': 'camera_name', 'type': 'str', 'value': '', 'readonly': True},
+    {'title': 'Sensor type:', 'name': 'sensor', 'type': 'list', 'limits': ['Monochrome', 'Bayer']},
+    {'title': 'Ouput Color:', 'name': 'output_color', 'type': 'list', 'limits': ['RGB', 'MonoChrome']},
+    {'title': 'ROI', 'name': 'roi', 'type': 'group', 'children': [
+        {'title': 'Update ROI from Viewer', 'name': 'update_roi', 'type': 'led', 'value': False},
+        {'title': 'Apply ROI', 'name': 'apply_roi', 'type': 'led', 'value': False},
+        {'title': 'Clear ROI+Bin', 'name': 'clear_roi', 'type': 'bool_push', 'value': False},
+        {'title': 'ROI:', 'name': 'roi_slices', 'type': 'str', 'value': ''},
+        {'title': 'X binning', 'name': 'x_binning', 'type': 'int', 'value': 1},
+        {'title': 'Y binning', 'name': 'y_binning', 'type': 'int', 'value': 1},
+    ], },
+    {'title': 'Image width', 'name': 'hdet', 'type': 'int', 'value': 1, 'readonly': True},
+    {'title': 'Image height', 'name': 'vdet', 'type': 'int', 'value': 1, 'readonly': True},
+    {'title': 'Timing', 'name': 'timing_opts', 'type': 'group', 'children':
+        [{'title': 'Exposure Time (ms)', 'name': 'exposure_time', 'type': 'int', 'value': 1},
+         {'title': 'Compute FPS', 'name': 'fps_on', 'type': 'bool', 'value': True},
+         {'title': 'FPS', 'name': 'fps', 'type': 'float', 'value': 0.0, 'readonly': True}]
+     },
+    {'title': 'Buffer', 'name': 'buffer', 'type': 'group', 'children': [
+        {'title': 'Size:', 'name': 'size', 'type': 'int', 'value': 10},
+        {'title': 'mode:', 'name': 'mode', 'type': 'list', 'value': 'now',
+         'limits': ['now', 'lastread', 'lastwait', 'start']},
+    ]},
+]
+
+
+class CameraBasePyLabLib(DAQ_Viewer_base):
+    """
+    Base implementation for Camera using pylablib framework. Works for TSI and uc480 thorlabs camera and rpobaly others
+    """
+    serial_numbers = []
+
+    serial_params = [{'title': 'Serial number:', 'name': 'serial_number', 'type': 'list', 'limits': serial_numbers}]
+
+    params = comon_parameters + serial_params + cam_params
+
+    callback_signal = QtCore.Signal(bool)
+    live_mode_available = True
+
+
+    def ini_attributes(self):
+        self.controller = None
+        self.callback_thread: QtCore.QThread = None
+
+        self.x_axis: Axis = None
+        self.y_axis: Axis = None
+
+        self.roi_select_info: RoiInfo = None
+
+        self.last_tick = 0.0  # time counter used to compute FPS
+        self.fps = 0.0
+
+        self.data_shape: str = ''
+
+
+    def roi_select(self, roi_info: RoiInfo, ind_viewer: int = 0):
+        """ Automatically called when a user use the RoiSelect ROi from a 2D viewer"""
+        self.roi_select_info = roi_info
+        self.roi_select_viewer_index = ind_viewer
+
+        if self.settings['roi', 'update_roi']:
+            self.settings['roi', 'roi_slices'] = str(roi_info.to_slices())
+            if self.settings['roi', 'apply_roi']:
+                self.apply_roi()
+
+    def apply_roi(self):
+        roi_info = RoiInfo.from_slices(eval(self.settings['roi', 'roi_slices']))
+        new_roi = (roi_info.origin[1], roi_info.size[1], self.settings['roi', 'x_binning'],
+                   roi_info.origin[0], roi_info.size[0], self.settings['roi', 'y_binning'])
+        self.update_rois(new_roi)
+
+    def compute_axes(self):
+        (hstart, hend, vstart, vend, hbin, vbin) = self.controller.get_roi()
+        slices = [slice(vstart, vend, vbin), slice(hstart, hend, hbin)]
+        self.settings.child('roi', 'roi_slices').setValue(str(slices))
+        roi_info = RoiInfo.from_slices(slices)
+
+        self.x_axis = Axis('x_axis', offset=roi_info.origin[1],
+                           scaling=self.settings['roi', 'x_binning'],
+                           size=int(roi_info.size[1]),
+                           index=1)
+        self.y_axis = Axis('y_axis', offset=roi_info.origin[0],
+                           scaling=self.settings['roi', 'y_binning'],
+                           size=int(roi_info.size[0]),
+                           index=0)
+
+    def clear_roi(self):
+        wdet, hdet = self.controller.get_detector_size()
+        self.settings.child('roi', 'x_binning').setValue(1)
+        self.settings.child('roi', 'y_binning').setValue(1)
+
+        new_roi = (0, wdet, 1, 0, hdet, 1)
+        self.update_rois(new_roi)
+
+    def update_rois(self, new_roi):
+        # In pylablib, ROIs compare as tuples
+        (new_x, new_width, new_xbinning, new_y, new_height, new_ybinning) = new_roi
+        if new_roi != self.controller.get_roi():
+            # self.controller.set_attribute_value("ROIs",[new_roi])
+            self.controller.set_roi(hstart=new_x, hend=new_x + new_width, vstart=new_y, vend=new_y + new_height,
+                                    hbin=new_xbinning, vbin=new_ybinning)
+            self.emit_status(ThreadCommand('Update_Status', [f'Changed ROI: {new_roi}']))
+            self.controller.clear_acquisition()
+            self.controller.setup_acquisition()
+            # Finally, prepare view for displaying the new data
+            self._prepare_view()
+            self.compute_axes()
+
+    def commit_settings(self, param: Parameter):
+        """Apply the consequences of a change of value in the detector settings
+
+        Parameters
+        ----------
+        param: Parameter
+            A given parameter (within detector_settings) whose value has been changed by the user
+        """
+        if param.name() == "exposure_time":
+            self.controller.set_exposure(param.value()/1000)
+
+        if param.name() == "fps_on":
+            self.settings.child('timing_opts', 'fps').setOpts(visible=param.value())
+
+        if param.name() == "apply_roi":
+            if param.value():   # Switching on ROI
+                self.apply_roi()
+            else:
+                self.clear_roi()
+
+        if param.name() in ['x_binning', 'y_binning']:
+            # We handle ROI and binning separately for clarity
+            (x0, w, y0, h, *_) = self.controller.get_roi()  # Get current ROI
+            xbin = self.settings['roi', 'x_binning']
+            ybin = self.settings['roi', 'y_binning']
+            new_roi = (x0, w, xbin, y0, h, ybin)
+            self.update_rois(new_roi)
+
+        if param.name() == "clear_roi":
+            if param.value():   # Switching on ROI
+                self.clear_roi()
+                param.setValue(False)
+
+    def ini_detector_custom(self, controller=None):
+        raise NotImplementedError
+
+    def ini_detector(self, controller=None):
+        """Detector communication initialization
+
+        Parameters
+        ----------
+        controller: (object)
+            custom object of a PyMoDAQ plugin (Slave case). None if only one actuator/detector by controller
+            (Master case)
+
+        Returns
+        -------
+        info: str
+        initialized: bool
+            False if initialization failed otherwise True
+        """
+        self.ini_detector_custom(controller)
+
+        self.get_device_info()
+        self.get_set_color()
+        self.get_set_main_parameters()
+        self.setup_callback_thread()
+
+        info = "Initialized camera"
+        initialized = True
+        return info, initialized
+
+    def get_device_info(self):
+
+        device_info = self.controller.get_device_info()
+
+        # Get camera name/model
+        if hasattr(device_info, 'name'):
+            self.settings.child('camera_name').setValue(device_info.name)
+        elif hasattr(device_info, 'model'):
+            self.settings.child('camera_name').setValue(device_info.model)
+
+    def get_set_color(self):
+        if 'monochrome' in self.settings['sensor'].lower():
+            self.settings.child('output_color').setValue('MonoChrome')
+            self.settings.child('output_color').setOpts(visible=False)
+
+    def get_set_main_parameters(self):
+        # Set exposure time
+        self.controller.set_exposure(self.settings['timing_opts', 'exposure_time']/1000)
+
+        # FPS visibility
+        self.settings.child('timing_opts', 'fps').setOpts(visible=self.settings['timing_opts', 'fps_on'])
+
+        # get roi limits
+        self.controller.get_roi_limits()
+
+        # Update image parameters
+        (hstart, hend, vstart, vend, hbin, vbin) = self.controller.get_roi()
+        height, width = self.controller.get_data_dimensions()
+        self.settings.child('roi', 'x_binning').setValue(hbin)
+        self.settings.child('roi', 'y_binning').setValue(vbin)
+        self.settings.child('hdet').setValue(width)
+        self.settings.child('vdet').setValue(height)
+        slices = [slice(vstart, vend, vbin), slice(hstart, hend, hbin)]
+        self.settings.child('roi', 'roi_slices').setValue(str(slices))
+        self.compute_axes()
+
+    def setup_callback_thread(self):
+        # Way to define a wait function with arguments
+        wait_func = lambda: self.controller.wait_for_frame(since=self.settings['buffer', 'mode'],
+                                                           nframes=1, timeout=20.0)
+        callback = CameraCallback(wait_func)
+        self.settings.child('buffer', 'mode').setReadonly(True)
+
+
+        self.callback_thread = QtCore.QThread()  # creation of a Qt5 thread
+        callback.moveToThread(self.callback_thread)  # callback object will live within this thread
+        callback.data_sig.connect(
+            self.emit_data)  # when the wait for acquisition returns (with data taken), emit_data will be fired
+
+        self.callback_signal.connect(callback.set_do_grab)
+        self.callback_thread.callback = callback
+        self.callback_thread.start()
+
+        self._prepare_view()
+
+
+    def _prepare_view(self):
+        """Preparing a data viewer by emitting temporary data. Typically, needs to be called whenever the
+        ROIs are changed"""
+
+        height, width = self.controller.get_data_dimensions()
+
+        self.settings.child('hdet').setValue(width)
+        self.settings.child('vdet').setValue(height)
+        mock_data = np.zeros((height, width))
+
+        if width != 1 and height != 1:
+            data_shape = 'Data2D'
+        else:
+            data_shape = 'Data1D'
+
+        if data_shape != self.data_shape:
+            self.data_shape = data_shape
+            # init the viewers
+            self.data_grabed_signal_temp.emit([DataFromPlugins(name='Thorlabs Camera',
+                                                               data=[np.squeeze(mock_data)],
+                                                               dim=self.data_shape,
+                                                               labels=[f'ThorCam_{self.data_shape}'])])
+            QtWidgets.QApplication.processEvents()
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """
+        Grabs the data. ASynchronous method (kinda).
+        ----------
+        Naverage: (int) Number of averaging
+        kwargs: (dict) of others optionals arguments
+        """
+        try:
+            # Warning, acquisition_in_progress returns 1,0 and not a real bool
+            if not kwargs.get('live', False):
+                self.emit_data(self.controller.snap())
+            else:
+                if not self.controller.acquisition_in_progress():
+                    self.controller.clear_acquisition()
+                    self.controller.start_acquisition(nframes=self.settings['buffer', 'size'])
+                #Then start the acquisition
+                self.callback_signal.emit(True)  # will trigger the wait for acquisition
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [str(e), "log"]))
+
+    def emit_data(self, frame: np.ndarray=None):
+        """ Function used to emit data obtained by callback.
+
+        Parameter
+        ---------
+        status: bool
+            If True a frame is available, If False, a Timeout occurred while waiting for the frame
+
+        See Also
+        --------
+        daq_utils.ThreadCommand
+        """
+        try:
+            # Get  data from buffer
+            if frame is None:
+                frame = self.controller.read_newest_image()
+            # Emit the frame.
+            if frame is not None:       # happens for last frame when stopping camera
+                if self.settings['output_color'] == 'RGB':
+                    rgb_image = cv2.cvtColor(frame, cv2.COLOR_BAYER_BG2RGB)
+                    data_arrays = [np.atleast_1d(rgb_image[..., ind]) for ind in range(3)]
+                else:
+                    if 'monochrome' in self.settings['sensor'].lower():
+                        data_arrays = [np.atleast_1d(frame)]
+                    else:
+                        data_arrays = [np.atleast_1d(cv2.cvtColor(frame, cv2.COLOR_BAYER_BG2GRAY))]
+
+                self.data_grabed_signal.emit([DataFromPlugins(name='Thorlabs Camera',
+                                                              data=data_arrays,
+                                                              dim=self.data_shape,
+                                                              labels=[f'ThorCam_{self.data_shape}'],
+                                                              axes=[self.x_axis, self.y_axis])])
+            if self.settings.child('timing_opts', 'fps_on').value():
+                self.update_fps()
+
+            # To make sure that timed events are executed in continuous grab mode
+            QtWidgets.QApplication.processEvents()
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
+
+    def update_fps(self):
+        current_tick = perf_counter()
+        frame_time = current_tick-self.last_tick
+
+        if self.last_tick != 0.0 and frame_time != 0.0:
+            # We don't update FPS for the first frame, and we also avoid divisions by zero
+
+            if self.fps == 0.0:
+                self.fps = 1 / frame_time
+            else:
+                # If we already have an FPS calculated, we smooth its evolution
+                self.fps = 0.9 * self.fps + 0.1 / frame_time
+
+        self.last_tick = current_tick
+
+        # Update reading
+        self.settings.child('timing_opts', 'fps').setValue(round(self.fps, 1))
+
+    def close(self):
+        """
+        Terminate the communication protocol
+        """
+        # Terminate the communication
+
+        self.stop()
+        if self.callback_thread is not None:
+            self.callback_thread.quit()
+            self.callback_thread.wait()
+
+        self.controller.close()
+        self.settings.child('buffer', 'mode').setReadonly(False)
+
+    def stop(self):
+        """Stop the acquisition."""
+        self.callback_signal.emit(False)
+        QtWidgets.QApplication.processEvents()
+
+        self.controller.clear_acquisition()
+        return ''
+
+
+class CameraCallback(QtCore.QObject):
+    """Callback object """
+    data_sig = QtCore.Signal()
+
+    def __init__(self, wait_fn):
+        super().__init__()
+        # Set the wait function
+        self.wait_fn = wait_fn
+        self.do_grab = True
+
+    def set_do_grab(self, do_grab=True):
+        self.do_grab = do_grab
+        if do_grab:
+            self.wait_for_acquisition()
+
+    def wait_for_acquisition(self):
+        while self.do_grab:
+            try:
+                new_data = self.wait_fn()
+                if new_data is not False:  # will be returned if the main thread called CancelWait
+                    self.data_sig.emit()
+            except Exception as e:
+                pass
+            QtWidgets.QApplication.processEvents()
+
+
+

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/models/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/resources/config_template.toml

@@ -0,0 +1,2 @@
+title = 'this is the configuration file of the plugin XXX'
+

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/scanners/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_utils-5.0.2/src/pymodaq_plugins_utils/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_utils-5.0.2/tests/test_plugin_package_structure.py

@@ -0,0 +1,134 @@
+# -*- 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__')
+    move_mod = importlib.import_module(f'{pkg_name}', 'daq_move_plugins')
+    importlib.import_module(f'{pkg_name}', 'daq_viewer_plugins')
+    importlib.import_module(f'{pkg_name}', 'extensions')
+    importlib.import_module(f'{pkg_name}', 'models')
+    importlib.import_module(f'{pkg_name}.daq_viewer_plugins', 'plugins_0D')
+    importlib.import_module(f'{pkg_name}.daq_viewer_plugins', 'plugins_1D')
+    importlib.import_module(f'{pkg_name}.daq_viewer_plugins', 'plugins_2D')
+    importlib.import_module(f'{pkg_name}.daq_viewer_plugins', 'plugins_ND')
+
+
+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)
+
+def test_compatibility(capsys):
+    capsys.disabled()
+    try:
+        from pymodaq_plugin_manager.compatibility_checker import PyMoDAQPlugin
+    except (ModuleNotFoundError, ImportError) as e:
+        pytest.fail(f"Please update pymodaq_plugin_manager to a newer version: {e}")
+
+    plugin = PyMoDAQPlugin(get_package_name(), None)
+    success = plugin.all_imports_valid()
+    msg = '\n'.join(plugin.failed_imports + [''])
+
+    if not success:
+        plugin.save_import_report(".")
+
+    assert success, msg