pymodaq_scripting 5.3.0__py3-none-any.whl

pymodaq_scripting/__init__.py

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

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/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/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/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()

pymodaq_scripting-5.3.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.5
+Name: pymodaq_scripting
+Version: 5.3.0
+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
+#################
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_scripting.svg
+   :target: https://pypi.org/project/pymodaq_scripting/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=patch-3
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=patch-3
+   :alt: Documentation Status
+
+.. image:: https://codecov.io/gh/PyMoDAQ/PyMoDAQ/branch/patch-3/graph/badge.svg?token=IQNJRCQDM2
+ :target: https://codecov.io/gh/PyMoDAQ/PyMoDAQ
+
++-------------+-------------+---------------+
+|             | Linux       | Windows       |
++=============+=============+===============+
+| Python 3.10 | |310-linux| | |310-windows| |
++-------------+-------------+---------------+
+| Python 3.11 | |311-linux| | |311-windows| |
++-------------+-------------+---------------+
+| Python 3.12 | |312-linux| | |312-windows| |
++-------------+-------------+---------------+
+| Python 3.13 | |313-linux| | |313-windows| |
++-------------+-------------+---------------+
+
+
+
+
+
+.. |310-linux| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Linux_3.10.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |311-linux| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Linux_3.11.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |312-linux| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Linux_3.12.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |313-linux| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Linux_3.13.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |310-windows| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Windows_3.10.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |311-windows| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Windows_3.11.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |312-windows| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Windows_3.12.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+.. |313-windows| image:: https://raw.githubusercontent.com/PyMoDAQ/PyMoDAQ/badges/pymodaq_scripting/patch-3/tests_Windows_3.13.svg
+    :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/tests-data.yml
+
+
+
+.. figure:: http://pymodaq.cnrs.fr/en/latest/_static/splash.png
+   :alt: shortcut
+
+
+PyMoDAQ__, Modular Data Acquisition with Python, is a set of **python** modules used to interface any kind of
+experiments. It simplifies the interaction with detector and actuator hardware to go straight to the data acquisition
+of interest.
+
+__ https://pymodaq.readthedocs.io/en/stable/?badge=latest
+
+`PyMoDAQ Scripting`__ is a set of utilities (mainly objects) that are used
+to provide direct emulation of the DashBoard set of Control Modules but from a script in
+another process. Communication is handled by the lecco protocol.
+
+__ https://pymodaq.cnrs.fr/en/latest/user_folder/scripting.html
+
+
+Published under the MIT FREE SOFTWARE LICENSE
+
+GitHub repo: https://github.com/PyMoDAQ
+
+Documentation: http://pymodaq.cnrs.fr/

pymodaq_scripting-5.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pymodaq_scripting/__init__.py,sha256=bOKxPgKOT-TqS42lx8O8JY3d7cSfpskAUDADA1iYThM,50
+pymodaq_scripting/devices.py,sha256=K7iPIubX84LBV8xosvtKBYTx15W18YEmoD-LpyeCbtA,3343
+pymodaq_scripting/utils.py,sha256=yRdymXJq1e48YmHaPUDjBk300dvQzm27HzZo9CMByHQ,14116
+pymodaq_scripting/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_scripting/examples/dashboard_script.py,sha256=RbhDb4yziYywuo0wG5GvglGhGf80QrfPrgrozX8iMD8,1002
+pymodaq_scripting/examples/simple_script.py,sha256=dTaVprhgG9lPh1ECo0xlbby9Yq7Gm4EJYDbcqNEOssQ,1320
+pymodaq_scripting-5.3.0.dist-info/METADATA,sha256=V0Kf1F33TPRX4d8ctWcxo0v5PUekg0OVoz0ZBUOIAwk,6557
+pymodaq_scripting-5.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pymodaq_scripting-5.3.0.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq_scripting-5.3.0.dist-info/RECORD,,

pymodaq_scripting-5.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pymodaq_scripting-5.3.0.dist-info/licenses/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.