pymodaq_scripting 5.3.0a1__tar.gz

pymodaq_scripting-5.3.0a1/.gitignore

@@ -0,0 +1,133 @@
+# Compiled python modules.
+*.pyc
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+.idea/*
+
+# Distribution / packaging
+.Python
+documentation/_*
+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/
+
+*.idea
+
+# 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
+
+# VS code project settings
+.vscode/*
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.idea/workspace.xml
+
+*.iml
+
+
+.tox
+*.h5
+!data.h5
+
+*yacctab.py
+*lextab.py
+
+.mu_repo
+
+
+**/README.rst

pymodaq_scripting-5.3.0a1/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_scripting-5.3.0a1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.5
+Name: pymodaq_scripting
+Version: 5.3.0a1
+Summary: Objects and utilities to use PyMoDAQ from a script
+Project-URL: Homepage, http://pymodaq.cnrs.fr
+Project-URL: Source, https://github.com/PyMoDAQ/pymodaq_scripting
+Project-URL: Tracker, https://github.com/PyMoDAQ/pymodaq_scripting/issues
+Author-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: Environment :: Other Environment
+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: pyleco
+Requires-Dist: pymodaq-data>=5.0.13
+Requires-Dist: pymodaq-utils>=0.0.8
+Provides-Extra: dev
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Description-Content-Type: text/x-rst
+
+.. ############################################################
+..  WARNING: This file is AUTO-GENERATED from README.rst.tpl.
+..                  ⚠️ DO NOT EDIT MANUALLY ⚠️
+.. ############################################################
+
+
+PyMoDAQ Scripting
+#################
+
+Set of Objects to use PyMoDAQ Dasboard control modules from an external script
+

pymodaq_scripting-5.3.0a1/README.rst

@@ -0,0 +1,11 @@
+.. ############################################################
+..  WARNING: This file is AUTO-GENERATED from README.rst.tpl.
+..                  ⚠️ DO NOT EDIT MANUALLY ⚠️
+.. ############################################################
+
+
+PyMoDAQ Scripting
+#################
+
+Set of Objects to use PyMoDAQ Dasboard control modules from an external script
+

pymodaq_scripting-5.3.0a1/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["hatchling>=1.9.0", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pymodaq_scripting"
+dynamic = [
+    "version",
+]
+description = "Objects and utilities to use PyMoDAQ from a script"
+readme = "README.rst"
+license = { file="LICENSE" }
+requires-python = ">=3.10"
+authors = [
+    { name = "Sébastien Weber", email = "sebastien.weber@cemes.fr" },
+]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Other Environment",
+    "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",
+]
+
+dependencies = [
+    "pymodaq_utils>=0.0.8",
+    "pymodaq_data>=5.0.13",
+    "pyleco",
+]
+
+[project.optional-dependencies]
+
+dev = [
+    "hatch",
+    "flake8",
+    "pytest",
+    "pytest-cov",
+    "pytest-xdist",
+]
+
+
+[project.urls]
+Homepage = "http://pymodaq.cnrs.fr"
+Source = "https://github.com/PyMoDAQ/pymodaq_scripting"
+Tracker = "https://github.com/PyMoDAQ/pymodaq_scripting/issues"
+
+[tool.hatch.version.raw-options]
+search_parent_directories = true
+fallback_version = "5.1.0"
+git_describe_command = "python git_describe.py packages/pymodaq_scripting"
+
+[tool.hatch.version]
+source = "vcs"
+
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+]
+
+[tool.coverage.run]
+omit = [
+    "*/examples/*",
+]

pymodaq_scripting-5.3.0a1/src/pymodaq_scripting/__init__.py

@@ -0,0 +1 @@
+from .devices import Actuator, Detector, Dashboard

pymodaq_scripting-5.3.0a1/src/pymodaq_scripting/devices.py

@@ -0,0 +1,107 @@
+from concurrent.futures import Future
+from typing import Optional, TYPE_CHECKING, Union
+from xml.etree.ElementTree import Element
+from pymodaq_data.data import DataToExport
+from pymodaq_scripting.utils import (
+    Device,
+    LECOActuatorWrapper,
+    LECODetectorWrapper,
+    LECODashboardWrapper,
+)
+
+if TYPE_CHECKING:
+    from pymodaq.utils.data import DataActuator
+
+
+class Actuator(Device[LECOActuatorWrapper]):
+    """
+    Public interface to control an Actuator
+    """
+    def __init__(self, device: str, **kwargs) -> None:
+        super().__init__(LECOActuatorWrapper(device, **kwargs))
+
+    def get_actuator_value(self) -> Future['DataActuator']:
+        return self._wrapper.get_actuator_value()
+
+    def move_home(self) -> Future['DataActuator']:
+        return self._wrapper.move_home()
+
+    def move_abs(self, value: Union['DataActuator', int, float, str]) -> Future['DataActuator']:
+        return self._wrapper.move_abs(value)
+
+    def move_rel(self, value: Union['DataActuator', int, float, str]) -> Future['DataActuator']:
+        return self._wrapper.move_rel(value)
+
+    def stop_move(self) -> Future['DataActuator']:
+        return self._wrapper.stop_move()
+
+    def get_settings(self) -> Future[Element]:
+        return self._wrapper.get_settings()
+
+    def set_settings(self, settings: Element) -> None:
+        self._wrapper.set_settings(settings)
+
+class Detector(Device[LECODetectorWrapper]):
+    """
+    Public interface to control a Detector
+    """
+    def __init__(self, device: str, **kwargs) -> None:
+        super().__init__(LECODetectorWrapper(device, **kwargs))
+
+    def snap(self) -> Optional[Future[DataToExport]]:
+        return self._wrapper.snap()
+
+    def grab(self, keep=False) -> Optional[list[DataToExport]]:
+        return self._wrapper.grab(keep=keep)
+
+    def stop_grab(self) -> None:
+        return self._wrapper.stop_grab()
+
+    def get_settings(self) -> Future[Element]:
+        return self._wrapper.get_settings()
+
+    def set_settings(self, settings: Element) -> None:
+        self._wrapper.set_settings(settings)
+
+
+class Dashboard(Device[LECODashboardWrapper]):
+    """
+    Public interface to control a Dashboard
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(LECODashboardWrapper(**kwargs))
+
+    @property
+    def leco_name(self):
+        return self._wrapper.leco_name
+
+    @property
+    def name(self) -> str:
+        return self._wrapper.name
+
+    def sign_out(self) -> None:
+        self._wrapper.sign_out()
+
+    def get_devices(self) -> Future[dict[str, list[str]]]:
+        return self._wrapper.get_devices()
+
+    def get_scripting_devices(self) -> dict[str, dict[str, Actuator | Detector]]:
+        devices = self._wrapper.get_devices().result()
+
+        return {
+            'actuators': {name: Actuator(name) for name in devices['actuators']},
+            'detectors': {name: Detector(name) for name in devices['detectors']},
+        }
+
+    def get_states(self) -> Future[list[str]]:
+        return self._wrapper.get_states()
+
+    def apply_state(self, state: str) -> Future[bool]:
+        return self._wrapper.apply_state(state)
+
+    def get_experiments(self) -> Future[list[str]]:
+        return self._wrapper.get_experiments()
+
+    def apply_experiment(self, experiment: str) -> Future[bool]:
+        return self._wrapper.apply_experiment(experiment)

pymodaq_scripting-5.3.0a1/src/pymodaq_scripting/examples/dashboard_script.py

@@ -0,0 +1,27 @@
+from pymodaq_scripting import Detector, Actuator, Dashboard
+
+# Once a dashboard is started:
+dashboard = Dashboard()
+
+
+print(dashboard.get_experiments().result())
+# >>> ['default']
+# Could make it so that it returns a future that completes when it's finished loading
+dashboard.apply_experiment('default')
+
+print(dashboard.get_states().result())
+# >>> ['default', 'my_custom_config']
+
+# Same remark as dashboard.apply_preset
+dashboard.apply_state('default')
+
+print(dashboard.get_devices().result())  # returns the names
+# >>> {'actuators': ['Theta', 'Temperature', 'Power', 'Xaxis'], 'detectors': ['Det2D', 'Det0D', 'Det1D']}
+
+devices = dashboard.get_scripting_devices()
+print(devices)
+# >>>  {'actuators': {'Theta': <Actuator object>, 'Temperature': <Actuator object>, 'Power': <Actuator object>, 'Xaxis': <Actuator object>}, 'detectors': {'Det2D': <Detector object>, 'Det0D': <Detector object>, 'Det1D': <Detector object>}}
+
+
+#Then each device can be used
+devices['actuators']['Angle'].move_abs('90°')

pymodaq_scripting-5.3.0a1/src/pymodaq_scripting/examples/simple_script.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from pymodaq_data import Q_
+from pymodaq_data.h5modules.backends import GroupType
+
+from pymodaq_scripting import Detector, Actuator
+from pymodaq_data.h5modules.data_saving import DataToExportEnlargeableSaver
+
+theta = Actuator('Angle')
+det0d = Detector('Det0D')
+det1d = Detector('Det1D')
+
+acquisitions = []
+
+base = theta.get_actuator_value().result()
+target = base + Q_('90°')  # Or a DataActuator(data=90, units='°')
+step = Q_('10°')
+
+count = (target - base)/step
+count = int(count.quantities[0].m[0]) + 1
+
+filename = Path(r'C:\Data\2026\scripted_data1.h5')
+
+with DataToExportEnlargeableSaver(filename, enl_axis_names=('count',), enl_axis_units=('',)) as saver:
+
+    group = saver.add_group('Script', group_type=GroupType.data ,where='/RawData/', title='scripted_data')
+    group0d = saver.add_det_group(where=group, title=det0d.name)
+    group1d = saver.add_det_group(where=group, title=det1d.name)
+    for idx in range(count):
+        value = theta.move_abs(base + idx * step).result()  # taking directly the result makes it a blocking move
+        dte0d_future = det0d.snap()  # async snap
+        dte1d_future = det1d.snap()  # async snap
+        saver.add_data(group0d, dte0d_future.result(), (value.value(), ))
+        saver.add_data(group1d, dte1d_future.result(), (value.value(),))
+

pymodaq_scripting-5.3.0a1/src/pymodaq_scripting/utils.py

@@ -0,0 +1,415 @@
+import atexit
+import xml.etree.ElementTree as ET
+from abc import ABC
+
+from concurrent.futures import Future, InvalidStateError
+from functools import cached_property
+from typing import Optional, cast, Union, Generic, TypeVar, TYPE_CHECKING
+from xml.etree.ElementTree import Element
+
+from pyleco.directors.director import Director
+from pyleco.utils.listener import Listener
+from serializall import SerializableFactory, utils
+
+from pymodaq_data.data import DataToExport
+from pymodaq_data import Q_, DataRaw
+
+if TYPE_CHECKING:
+    from pymodaq.utils.data import DataActuator
+
+sf = SerializableFactory()
+
+
+def compare_xml_trees(base: Element, modified: Element) -> list[tuple[list[str], bytes]]:
+    """
+    Compare two XML trees and return changes.
+
+    Returns:
+        list of tuples: (path_list, changed_element_bytes)
+    """
+
+    changes = []
+
+    def compare_elements(base_elem, modified_elem, path):
+        """Recursively compare elements"""
+        # Compare text content (strip whitespace)
+        text1 = (base_elem.text or '').strip()
+        text2 = (modified_elem.text or '').strip()
+
+        if text1 != text2:
+            # Text changed - record this element
+            changed_bytes = ET.tostring(modified_elem)
+            changes.append((path.copy(), changed_bytes))
+            return  # Don't recurse further into this branch
+
+        # Compare attributes (optional - if you want to detect attribute changes)
+        if base_elem.attrib != modified_elem.attrib:
+            changed_bytes = ET.tostring(modified_elem)
+            changes.append((path.copy(), changed_bytes))
+            return
+
+        # Compare children
+        children1 = list(base_elem)
+        children2 = list(modified_elem)
+
+        # Build tag-to-element mapping
+        children1_dict = {child.tag: child for child in children1}
+        children2_dict = {child.tag: child for child in children2}
+
+        # Recursively compare matching children
+        for tag in children1_dict.keys():
+            if tag in children2_dict:
+                compare_elements(children1_dict[tag], children2_dict[tag],
+                                 path + [tag])
+
+    # Start comparison with forced prefix: ['detector_settings', 'settings_client']
+    initial_path = [base.tag or modified.tag]
+    compare_elements(base, modified, initial_path)
+
+    return changes
+
+
+def value_to_data_actuator(value: Union['DataActuator', int, float, str]) -> Union['DataActuator', DataRaw]:
+    """
+    Converts any kind of convertible value into a DataActuator
+    Parameters
+    ----------
+    value: The value to convert
+
+    Returns
+    -------
+    A DataActuator object containing the value
+    """
+    if any(isinstance(value, t) for t in (int, float)):
+        return DataRaw(name='actuator', data=value)
+    if isinstance(value, str):
+        value = Q_(value)
+    if isinstance(value, Q_):
+        return DataRaw(name='actuator', data=value.magnitude, units=str(value.units))
+    return value
+
+
+class LECOBaseWrapper:
+    """
+    Common LECO infrastructure: listener, communicator, director setup.
+    Shared by all LECO device and dashboard wrappers.
+    """
+    def __init__(self, device_name: str, **kwargs) -> None:
+        self._device_name = device_name
+
+        self._listener = Listener(name=self.leco_name, timeout=None)
+        self._listener.start_listen()
+
+        self._communicator = self._listener.get_communicator()
+        self._director = Director(actor=self.name, communicator=self._communicator, **kwargs)
+        atexit.register(self._clean)
+
+    @cached_property
+    def leco_name(self) -> str:
+        return f'scripting_{self.name}'
+
+    @cached_property
+    def name(self) -> str:
+        return self._device_name
+
+    def _clean(self):
+        self.sign_out()
+        self._listener.close()
+        self._director.close()
+        self._communicator.close()
+
+    def sign_out(self):
+        self._director.ask_rpc('sign_out', actor='COORDINATOR')
+
+    def set_remote_name(self):
+        self._director.ask_rpc('set_remote_name', name=self.leco_name)
+
+
+class LECODeviceWrapper(LECOBaseWrapper):
+    """
+    LECO wrapper with settings management, shared by actuator and detector devices.
+    """
+    def __init__(self, device: str, **kwargs) -> None:
+        self._base_settings: Optional[Element] = None
+        self._settings_future: Optional[Future[Element]] = None
+
+        super().__init__(device, **kwargs)
+
+        self._listener.register_rpc_method(self.set_director_settings)
+        self._listener.register_binary_rpc_method(self.set_director_info, accept_binary_input=True)
+
+    def get_settings(self) -> Future[Element]:
+        future = Future()
+        self._settings_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("get_settings")
+
+        return future
+
+    def set_settings(self, settings: Element):
+        if self._base_settings is not None:
+            for (path, modified) in compare_xml_trees(self._base_settings, settings):
+                t_name, t_len = utils.str_len_to_bytes('ParameterWithPath')
+                data = t_len + t_name + sf.get_apply_serializer(path) + sf.get_apply_serializer(modified)
+                self._director.ask_rpc("set_info", parameter=None, additional_payload=[data])
+
+    def set_director_settings(self, settings: bytes):
+        # Important to have two creations so they can be compared
+        # for modifications later.
+        self._base_settings = ET.fromstring(settings)
+        try:
+            self._settings_future.set_result(ET.fromstring(settings))
+            self._settings_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def set_director_info(self, parameter=None, additional_payload=None) -> None:
+        pass
+
+
+
+class LECOActuatorWrapper(LECODeviceWrapper):
+    """
+    LECO wrapper for actuators: move commands and position callbacks.
+    """
+    def __init__(self, device: str, **kwargs) -> None:
+        self._send_position_future: Optional[Future['DataActuator']] = None
+        self._move_done_future: Optional[Future['DataActuator']] = None
+
+        super().__init__(device, **kwargs)
+
+        self._listener.register_binary_rpc_method(self.send_position, accept_binary_input=True)
+        self._listener.register_binary_rpc_method(self.set_move_done, accept_binary_input=True)
+
+    def get_actuator_value(self) -> Future['DataActuator']:
+        future = Future()
+        self._send_position_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc('get_actuator_value')
+
+        return future
+
+    def move_home(self) -> Future['DataActuator']:
+        future = Future()
+        self._move_done_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("move_home")
+
+        return future
+
+    def move_abs(self, value: Union['DataActuator', int, float, str]) -> Future['DataActuator']:
+        future = Future()
+        self._move_done_future = future
+
+        value = value_to_data_actuator(value)
+        serialize = SerializableFactory().get_apply_serializer
+
+        self.set_remote_name()
+        self._director.ask_rpc("move_abs", position=None, additional_payload=[serialize(value)])
+
+        return future
+
+    def move_rel(self, value: 'DataActuator') -> Future['DataActuator']:
+        future = Future()
+        self._move_done_future = future
+
+        value = value_to_data_actuator(value)
+        serialize = SerializableFactory().get_apply_serializer
+
+        self.set_remote_name()
+        self._director.ask_rpc("move_rel", position=None, additional_payload=[serialize(value)])
+
+        return future
+
+    def stop_move(self) -> Future['DataActuator']:
+        future = Future()
+        self._move_done_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("stop_motion")
+
+        return future
+
+    def send_position(self, data=None, additional_payload=None):
+        value: Union['DataActuator', DataRaw] = cast(DataRaw, sf.get_apply_deserializer(additional_payload[0]))
+        try:
+            self._send_position_future.set_result(value)
+            self._send_position_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def set_move_done(self, data=None, additional_payload=None):
+        value: Union['DataActuator', DataRaw] = cast(DataRaw, sf.get_apply_deserializer(additional_payload[0]))
+        try:
+            self._move_done_future.set_result(value)
+            self._move_done_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+
+class LECODetectorWrapper(LECODeviceWrapper):
+    """
+    LECO wrapper for detectors: snap/grab commands and data callbacks.
+    """
+    def __init__(self, device: str, **kwargs) -> None:
+        self._snap_data_future: Optional[Future[DataToExport]] = None
+        self._grab_data_list: Optional[list[DataToExport]] = None
+        self._is_grabbing = False
+        super().__init__(device, **kwargs)
+        self._listener.register_binary_rpc_method(self.set_data, accept_binary_input=True)
+
+    def snap(self) -> Optional[Future[DataToExport]]:
+        if not self._is_grabbing:
+            future = Future()
+            self._snap_data_future = future
+            self.set_remote_name()
+            self._director.ask_rpc("send_data_snap")
+            return future
+        return None
+
+    def grab(self, keep=False) -> Optional[list[DataToExport]]:
+        was_grabbing = self._is_grabbing
+        if not was_grabbing:
+            self._grab_data_list = [] if keep else None
+
+        self.set_remote_name()
+        self._director.ask_rpc("send_data_grab")
+        self._is_grabbing = not was_grabbing
+
+        return None if was_grabbing else self._grab_data_list
+
+    def stop_grab(self):
+        self._is_grabbing = False
+        self.set_remote_name()
+        self._director.ask_rpc("stop_grab")
+
+    def set_data(self, data=None, additional_payload=None):
+        value: DataToExport = cast(DataToExport, sf.get_apply_deserializer(additional_payload[0]))
+        if self._is_grabbing:
+            if self._grab_data_list is not None:
+                self._grab_data_list.append(value)
+        else:
+            try:
+                self._snap_data_future.set_result(value)
+                self._snap_data_future = None
+            except (InvalidStateError, AttributeError):
+                pass
+
+
+class LECODashboardWrapper(LECOBaseWrapper):
+    def __init__(self, **kwargs) -> None:
+        self._experiments_future: Optional[Future[list[str]]] = None
+        self._applied_experiment_future: Optional[Future[bool]] = None
+        self._states_future: Optional[Future[list[str]]] = None
+        self._applied_state_future: Optional[Future[bool]] = None
+        self._devices_list_future: Optional[Future[dict[str, list[str]]]] = None
+
+        super().__init__('dashboard', **kwargs)
+
+        self._listener.register_binary_rpc_method(self.send_devices, accept_binary_input=True)
+        self._listener.register_rpc_method(self.send_states)
+        self._listener.register_rpc_method(self.send_experiments)
+        self._listener.register_rpc_method(self.applied_experiment_done)
+        self._listener.register_rpc_method(self.applied_state_done)
+
+    def get_devices(self) -> Future[dict[str, list[str]]]:
+        future = Future()
+        self._devices_list_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("get_devices")
+
+        return future
+
+    def get_states(self) -> Future[list[str]]:
+        future = Future()
+        self._states_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("get_states")
+
+        return future
+
+    def apply_state(self, state: str) -> Future[bool]:
+        future = Future()
+        self._applied_state_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("apply_state", state=state)
+
+        return future
+
+    def get_experiments(self) -> Future[list[str]]:
+        future = Future()
+        self._experiments_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("get_experiments")
+
+        return future
+
+    def apply_experiment(self, experiment: str) -> Future[bool]:
+        future = Future()
+        self._applied_experiment_future = future
+
+        self.set_remote_name()
+        self._director.ask_rpc("apply_experiment", experiment=experiment)
+
+        return future
+
+    def send_devices(self, data=None, additional_payload=None):
+        value: dict[str, list[str]] = sf.get_apply_deserializer(additional_payload[0])
+        try:
+            self._devices_list_future.set_result(value)
+            self._devices_list_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def send_states(self, states: list[str]):
+        try:
+            self._states_future.set_result(states)
+            self._states_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def send_experiments(self, experiments: list[str]):
+        try:
+            self._experiments_future.set_result(experiments)
+            self._experiments_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def applied_experiment_done(self, done: bool):
+        try:
+            self._applied_experiment_future.set_result(done)
+            self._applied_experiment_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+    def applied_state_done(self, done: bool):
+        try:
+            self._applied_state_future.set_result(done)
+            self._applied_state_future = None
+        except (InvalidStateError, AttributeError):
+            pass
+
+WrapperT = TypeVar('WrapperT', bound=LECOBaseWrapper)
+
+class Device(ABC, Generic[WrapperT]):
+    def __init__(self, wrapper: WrapperT) -> None:
+        self._wrapper = wrapper
+
+    @property
+    def leco_name(self):
+        return self._wrapper.leco_name
+
+    @property
+    def name(self) -> str:
+        #Cast to avoid pycharm warning
+        return cast(str, cast(object, self._wrapper.name))
+
+    def sign_out(self) -> None:
+        self._wrapper.sign_out()