pymodaq 4.3.1__tar.gz → 4.3.3__tar.gz

{pymodaq-4.3.1 → pymodaq-4.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.3.1
+Version: 4.3.3
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/control_modules/daq_move.py

@@ -172,6 +172,20 @@ class DAQ_Move(ParameterControlModule):
         elif cmd.command == 'rel_value':
             self._relative_value = cmd.attribute
 
+    @property
+    def master(self) -> bool:
+        """ Get/Set programmaticaly the Master/Slave status of an actuator"""
+        if self.initialized_state:
+            return self.settings['move_settings', 'multiaxes', 'multi_status'] == 'Master'
+        else:
+            return True
+
+    @master.setter
+    def master(self, is_master: bool):
+        if self.initialized_state:
+            self.settings.child('move_settings', 'multiaxes', 'multi_status').setValue(
+                'Master' if is_master else 'Slave')
+
     def append_data(self, dte: Optional[DataToExport] = None, where: Union[Node, str, None] = None):
         """Appends current DataToExport to an ActuatorEnlargeableSaver
 
@@ -359,8 +373,9 @@ class DAQ_Move(ParameterControlModule):
                 self._hardware_thread.hardware = hardware
                 self._hardware_thread.start()
                 self.command_hardware.emit(
-                    ThreadCommand(command="ini_stage", attribute=[self.settings.child('move_settings').saveState(),
-                                                                  self.controller]))
+                    ThreadCommand(command="ini_stage", attribute=[
+                        self.settings.child('move_settings').saveState(),
+                        self.controller]))
             except Exception as e:
                 self.logger.exception(str(e))
 
@@ -546,6 +561,11 @@ class DAQ_Move(ParameterControlModule):
         else:
             raise ActuatorError(f'{act_type} is an invalid actuator, should be within {ACTUATOR_TYPES}')
 
+    @property
+    def actuators(self) -> List[str]:
+        """ Get the list of possible actuators"""
+        return ACTUATOR_TYPES
+
     def update_plugin_config(self):
         parent_module = utils.find_dict_in_list_from_key_val(DAQ_Move_Actuators, 'name', self.actuator)
         mod = import_module(parent_module['module'].__package__.split('.')[0])

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/dashboard.py

@@ -8,6 +8,9 @@ import logging
 from pathlib import Path
 from importlib import import_module
 from packaging import version as version_mod
+from typing import Tuple, List
+
+
 from qtpy import QtGui, QtWidgets, QtCore
 from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal
 from time import perf_counter
@@ -32,7 +35,7 @@ from pymodaq.utils.parameter import ParameterTree, Parameter
 from pymodaq.utils.leco.utils import start_coordinator
 from pymodaq.control_modules.daq_move import DAQ_Move
 from pymodaq.control_modules.daq_viewer import DAQ_Viewer
-
+from pymodaq.extensions.pid.actuator_controller import PIDController
 from pymodaq import extensions as extmod
 
 from pymodaq_plugin_manager.manager import PluginManager
@@ -666,7 +669,7 @@ class DashBoard(QObject):
 
         detector_modules.append(det_mod_tmp)
 
-    def set_file_preset(self, filename):
+    def set_file_preset(self, filename) -> Tuple[List[DAQ_Move], List[DAQ_Viewer]]:
         """
             Set a file managers from the converted xml file given by the filename parameter.
 
@@ -1120,9 +1123,8 @@ class DashBoard(QObject):
                             self.preset_manager.preset_params.child('pid_models').value())['class']
                         for setp in model_class.setpoints_names:
                             self.add_move(setp, None, 'PID', [], [], actuators_modules)
-                            actuators_modules[-1].controller = dict(curr_point=self.pid_module.curr_points_signal,
-                                                                    setpoint=self.pid_module.setpoints_signal,
-                                                                    emit_curr_points=self.pid_module.emit_curr_points_sig)
+                            actuators_modules[-1].controller = PIDController(self.pid_module)
+                            actuators_modules[-1].master = False
                             actuators_modules[-1].init_hardware_ui()
                             QtWidgets.QApplication.processEvents()
                             self.poll_init(actuators_modules[-1])

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/extensions/pid/__init__.py

@@ -1,8 +1,8 @@
 import importlib
 from pathlib import Path
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.logger import set_logger
+
 logger = set_logger('move_plugins', add_to_console=False)
 
 for path in Path(__file__).parent.iterdir():

pymodaq-4.3.3/src/pymodaq/extensions/pid/actuator_controller.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .pid_controller import DAQ_PID
+
+
+class PIDController:
+    """ Fake controller object for the DAQ_Move_PID"""
+
+    def __init__(self, daq_pid: 'DAQ_PID'):
+        self.curr_point = daq_pid.curr_points_signal
+        self.setpoint = daq_pid.setpoints_signal
+        self.emit_curr_points = daq_pid.emit_curr_points_sig

pymodaq-4.3.3/src/pymodaq/extensions/pid/daq_move_PID.py

@@ -0,0 +1,77 @@
+from pymodaq_utils.utils import ThreadCommand
+
+from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun,
+                                                          DataActuatorType, DataActuator)
+
+from pymodaq.extensions.pid.actuator_controller import PIDController
+
+
+class DAQ_Move_PID(DAQ_Move_base):
+    """
+    """
+    _controller_units = ''
+    data_actuator_type = DataActuatorType.DataActuator
+    is_multiaxes = True
+    stage_names = []
+
+    params = comon_parameters_fun(is_multiaxes, stage_names, master=False)
+
+    def ini_attributes(self):
+        self.controller: PIDController = None
+
+    def update_position(self, dict_val: dict):
+        self.current_value = dict_val[self.parent.title]
+
+    def get_actuator_value(self):
+        self.controller.emit_curr_points.emit()
+        pos = self.current_value
+        return pos
+
+    def close(self):
+        pass
+
+    def commit_settings(self, param):
+        pass
+
+    def ini_stage(self, controller=None):
+        """
+        """
+        self.ini_stage_init(controller, None)
+
+        self.controller.curr_point.connect(self.update_position)
+
+        info = "PID stage"
+        initialized = True
+        return info, initialized
+
+    def move_abs(self, position: DataActuator):
+        """
+        """
+        position = self.check_bound(position)
+        self.target_position = position
+
+        self.controller.setpoint.emit({self.parent.title: self.target_position})
+
+    def move_rel(self, position: DataActuator):
+        """
+        """
+        position = self.check_bound(self.current_value + position) - self.current_value
+        self.target_position = position + self.current_value
+
+        self.controller.setpoint.emit({self.parent.title: self.target_position})
+        self.poll_moving()
+
+    def move_home(self):
+        """
+        """
+        self.emit_status(ThreadCommand('Update_Status', ['Move Home not implemented']))
+
+    def stop_motion(self):
+        """
+          Call the specific move_done function (depending on the hardware).
+
+          See Also
+          --------
+          move_done
+        """
+        self.move_done()

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/extensions/pid/pid_controller.py

@@ -1,5 +1,7 @@
 import time
 from functools import partial  # needed for the button to sync setpoint with currpoint
+from typing import Dict
+
 import numpy as np
 
 from pyqtgraph.widgets.SpinBox import SpinBox
@@ -365,10 +367,10 @@ class DAQ_PID(CustomApp):
         for ind, sp in enumerate(self.setpoints_sb):
             sp.setValue(values[ind])
 
-    def setpoints_external(self, values_dict):
+    def setpoints_external(self, values_dict: Dict[str, DataActuator]):
         for key in values_dict:
             index = self.model_class.setpoints_names.index(key)
-            self.setpoints_sb[index].setValue(values_dict[key])
+            self.setpoints_sb[index].setValue(values_dict[key].value())
 
     @property
     def curr_points(self):

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/extensions/pid/utils.py

@@ -22,6 +22,7 @@ DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
+
 class DataToActuatorPID(DataToActuators):
 
     def __init__(self, *args, **kwargs):
@@ -176,8 +177,8 @@ def get_models(model_name=None):
     """
     from pymodaq.extensions.pid.utils import PIDModelGeneric
     models_import = []
-    discovered_models = get_entrypoints(group='pymodaq.pid_models')
-    discovered_models = get_entrypoints(group='pymodaq.models')
+    discovered_models = list(get_entrypoints(group='pymodaq.pid_models'))
+    discovered_models.extend(list(get_entrypoints(group='pymodaq.models')))
     if len(discovered_models) > 0:
         for pkg in discovered_models:
             try:

pymodaq-4.3.3/src/pymodaq/resources/VERSION

@@ -0,0 +1,2 @@
+version = '4.3.3'
+

{pymodaq-4.3.1 → pymodaq-4.3.3}/src/pymodaq/utils/config.py

@@ -20,7 +20,7 @@ except:
     USER = 'unknown_user'
 
 CONFIG_BASE_PATH = Path(environ['PROGRAMDATA']) if sys.platform == 'win32' else \
-    Path('Library/Application Support') if sys.platform == 'darwin' else Path('/etc')
+    Path('/Library/Application Support') if sys.platform == 'darwin' else Path('/etc')
 
 
 KeyType = TypeVar('KeyType')

pymodaq-4.3.1/src/pymodaq/extensions/pid/daq_move_PID.py

@@ -1,96 +0,0 @@
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.control_modules.move_utility_classes import DAQ_Move_base, comon_parameters_fun
-from easydict import EasyDict as edict
-
-
-class DAQ_Move_PID(DAQ_Move_base):
-    """
-    """
-    _controller_units = 'whatever'
-    is_multiaxes = True
-    stage_names = []
-
-    params = comon_parameters_fun(is_multiaxes, stage_names, master=False)
-
-    def __init__(self, parent=None, params_state=None):
-        super().__init__(parent, params_state)
-
-
-    def update_position(self, dict_val):
-        self.current_value = dict_val[self.parent.title]
-
-    def get_actuator_value(self):
-        self.controller['emit_curr_points'].emit()
-        pos = self.current_value
-        #
-        # pos = self.get_position_with_scaling(pos)
-        # self.current_value = pos
-        return pos
-
-    def close(self):
-        pass
-
-    def commit_settings(self, param):
-        pass
-
-    def ini_stage(self, controller=None):
-        """
-        """
-        try:
-            self.status.update(edict(info="", controller=None, initialized=False))
-            if self.settings.child('multiaxes', 'ismultiaxes').value() and self.settings.child('multiaxes',
-                                                                         'multi_status').value() == "Slave":
-                if controller is None:
-                    raise Exception('no controller has been defined externally while this axe is a slave one')
-                else:
-                    self.controller = controller
-            else:  # Master stage
-                self.controller = None  # any object that will control the stages
-
-            self.controller['curr_point'].connect(self.update_position)
-
-            info = "PID stage"
-            self.status.info = info
-            self.status.controller = self.controller
-            self.status.initialized = True
-            return self.status.info, self.status.initialized
-
-        except Exception as e:
-            self.status.info = str(e)
-            self.status.initialized = False
-            return self.status
-
-    def move_Abs(self, position):
-        """
-        """
-        position = self.check_bound(position)
-        # position=self.set_position_with_scaling(position)
-        # print(position)
-        self.target_position = position
-
-        self.controller['setpoint'].emit({self.parent.title: self.target_position})
-        self.poll_moving()
-
-    def move_Rel(self, position):
-        """
-        """
-        position = self.check_bound(self.current_value + position) - self.current_value
-        self.target_position = position + self.current_value
-
-        self.controller['setpoint'].emit({self.parent.title: self.target_position})
-        self.poll_moving()
-
-    def move_Home(self):
-        """
-        """
-        self.emit_status(ThreadCommand('Update_Status', ['Move Home not implemented']))
-
-    def stop_motion(self):
-        """
-          Call the specific move_done function (depending on the hardware).
-
-          See Also
-          --------
-          move_done
-        """
-        self.move_done()

pymodaq-4.3.1/src/pymodaq/resources/VERSION

@@ -1,2 +0,0 @@
-version = '4.3.1'
-