pymodaq 4.3.2__py3-none-any.whl → 4.3.4__py3-none-any.whl

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/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/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/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/extensions/pid/daq_move_PID.py

@@ -1,30 +1,30 @@
-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
+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 = 'whatever'
+    _controller_units = ''
+    data_actuator_type = DataActuatorType.DataActuator
     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 ini_attributes(self):
+        self.controller: PIDController = None
 
-
-    def update_position(self, dict_val):
+    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()
+        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):
@@ -36,51 +36,32 @@ class DAQ_Move_PID(DAQ_Move_base):
     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):
+        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)
-        # 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()
+        self.controller.setpoint.emit({self.parent.title: self.target_position})
 
-    def move_Rel(self, 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.controller.setpoint.emit({self.parent.title: self.target_position})
         self.poll_moving()
 
-    def move_Home(self):
+    def move_home(self):
         """
         """
         self.emit_status(ThreadCommand('Update_Status', ['Move Home not implemented']))

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/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/extensions/utils.py

@@ -45,14 +45,18 @@ def get_extensions():
                 module = importlib.import_module(pkg.value)
                 modules = get_ext_modules(Path(module.__path__[0]).joinpath('extensions'))
                 for mod in modules:
-                    mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
-                    if hasattr(mod_in, 'EXTENSION_NAME'):
-                        extension_import.append({'pkg': pkg.value, 'module': mod,
-                                                 'name': mod_in.EXTENSION_NAME,
-                                                 'class_name': mod_in.CLASS_NAME})
-
-            except Exception as e:  # pragma: no cover
-                logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: '
+                    try:
+                        mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
+                        if hasattr(mod_in, 'EXTENSION_NAME'):
+                            extension_import.append({'pkg': pkg.value, 'module': mod,
+                                                     'name': mod_in.EXTENSION_NAME,
+                                                     'class_name': mod_in.CLASS_NAME})
+
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: '
+                                       f'{str(e)}')
+            except Exception as e:
+                logger.warning(f'Impossible to import the {pkg.value} package: '
                                f'{str(e)}')
 
     return extension_import

pymodaq/resources/VERSION

@@ -1,2 +1,2 @@
-version = '4.3.2'
+version = '4.3.4'
 

{pymodaq-4.3.2.dist-info → pymodaq-4.3.4.dist-info}/METADATA

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

{pymodaq-4.3.2.dist-info → pymodaq-4.3.4.dist-info}/RECORD

@@ -1,9 +1,9 @@
 pymodaq/__init__.py,sha256=boHjxPnKEAQUmOHKbnxlI8DHP1eM5IKSrrnd1EqkvHg,4295
-pymodaq/dashboard.py,sha256=9SN2974L0FA-mUBWgAZ12aLzZmmFrQeUojdj3jstv44,64522
+pymodaq/dashboard.py,sha256=4fbV92erom0yWwqPMtx3KW1q-d6QYflV-EhOZMg24a4,64476
 pymodaq/icon.ico,sha256=hOHHfNDENKphQvG1WDleSEYcHukneR2eRFJu8isIlD4,74359
 pymodaq/splash.png,sha256=ow8IECF3tPRUMA4tf2tMu1aRiMaxx91_Y2ckVxkrmF0,53114
 pymodaq/control_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymodaq/control_modules/daq_move.py,sha256=S5Mpiowv_8xxicOsQ4XhWBflt_5EmMMjBe2BLZbw8js,35348
+pymodaq/control_modules/daq_move.py,sha256=-ipGtKrkeB_eaMfdDVHDFu86J5By_pHO8Z5axOkC_tY,35985
 pymodaq/control_modules/daq_move_ui.py,sha256=euA8_utFfiscd9ahZxRTqqTiCSrNB4CKCLqgdbUKSlI,15307
 pymodaq/control_modules/daq_viewer.py,sha256=5CYmdWHGE7sQApeMfdWNV3zbPyoxxYtzFlQ1PaEw4fI,57883
 pymodaq/control_modules/daq_viewer_ui.py,sha256=FWP3jdIOR9vTgYqNaaodteGZ3dwgQ1GdWKrOpOAuSrs,15693
@@ -40,14 +40,15 @@ pymodaq/extensions/daq_logger.py,sha256=hEAb98fv1qJxcH9NPvaiLp1SPWkBVBwpujJhuyAi
 pymodaq/extensions/daq_scan.py,sha256=CGBPrhLRHPmFJunKQ1aK5RgToXemzNEPdYSHn7e36DE,49414
 pymodaq/extensions/daq_scan_ui.py,sha256=bYJaWBLQMl2Yu1PAxc-bCldh4keWXd6l12ttrHqExE0,10181
 pymodaq/extensions/h5browser.py,sha256=eQZ8YhPHdiBCyHIn1JJJLn7OgZsc1XlcETgqdafofZs,1140
-pymodaq/extensions/utils.py,sha256=3cF3-7hVxYY1xxi0Kz-ck_yHcWyO5gAFFghf8Zo01Z8,2026
+pymodaq/extensions/utils.py,sha256=sh4SxJx5_lGJ6aJE8p8VJ2zrptW8pyze73aT_52xOwQ,2255
 pymodaq/extensions/bayesian/__init__.py,sha256=QMV9tq8Axi6YjoGj4UguBO8Zvuh26r5s91bm6YU7Itk,55
 pymodaq/extensions/bayesian/bayesian_optimisation.py,sha256=zB6DoyHx6nsKHsl3G4T0Hsw8npl80gdEIwvNfx4DCrU,30033
 pymodaq/extensions/bayesian/utils.py,sha256=1m_NpYMr-Swg2ImtMvbh-XOxutkAVwc0M2BWeK_NMIg,15544
-pymodaq/extensions/pid/__init__.py,sha256=YP5CemFZ54mFlFIhktct2SeOmkAuvxQm2y1Fiq5HiMQ,534
-pymodaq/extensions/pid/daq_move_PID.py,sha256=EiTJz4fLcjVL1UxnFREu2oZEz2nl-iL5xgxf83YG85M,3090
-pymodaq/extensions/pid/pid_controller.py,sha256=y0LTF_3N4mKEeRXyvgPycIy4FMPr-kRxLHgl1BV_YLc,28453
-pymodaq/extensions/pid/utils.py,sha256=KPSGlaiQsjH30GIN5Oy75OUFIgGTl8JU8dtHSR8JRjQ,7965
+pymodaq/extensions/pid/__init__.py,sha256=jm4axOgTnYVPsftjcjlvC_07KsdTY1H7CnOCYhOvY-o,473
+pymodaq/extensions/pid/actuator_controller.py,sha256=SOE2GjevbqxqxXewW0DMgoqNL_0CaPdNLjyKNc6ULKI,377
+pymodaq/extensions/pid/daq_move_PID.py,sha256=kqWAnYbhSMtrqu4cK1AtOuBD0UjPlrAFl-uB39ToPts,2151
+pymodaq/extensions/pid/pid_controller.py,sha256=5iTEiv69MlHW7-sUFCzvQlqZzAoXiJ_mRQtFntvFBIE,28511
+pymodaq/extensions/pid/utils.py,sha256=pxexKSg-3a1CWLQtCFZR6ZtdI8NY1Yl7J87aSBi2q2o,7984
 pymodaq/post_treatment/__init__.py,sha256=xaaLFZJ7OLqI_7yPurFk89A7m2ywSbYDXAsdE-QQ8Zg,81
 pymodaq/post_treatment/load_and_plot.py,sha256=UZaAMrC3b9VXcsZsjc3-7LxxUEuia_5ECUqDB7G_EoM,12140
 pymodaq/post_treatment/process_to_scalar.py,sha256=NHntybqpDhDjQJ224Dhf9Ij_ql-fAEMRT6egA6UEGfA,11568
@@ -57,7 +58,7 @@ pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.py,sha256=1u7hWDaiwsZ
 pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.ui,sha256=PyzbCWPMkh5oIYYteZczXyWMeHKW9EJmM1QlzXhnyTk,7037
 pymodaq/post_treatment/daq_measurement/daq_measurement_main.py,sha256=CAKwcWMOD86aXB8mbdxOK7e8nZRos5d59FzDtqK1QoY,17093
 pymodaq/post_treatment/daq_measurement/process_from_QtDesigner_DAQ_Measurement_GUI.bat,sha256=e1tu2A67MS9fk3jhriF6saQgRxWIucIvNW92iWXFP6E,164
-pymodaq/resources/VERSION,sha256=sjnuS49ZtKszCS7BjQ3fAuL5c6ZSFLfQRHwgQvKEjxk,19
+pymodaq/resources/VERSION,sha256=AL4m0CftoqyTIE2ogy_Wi8qZkqsOSNw3VNWln1U1P4A,19
 pymodaq/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymodaq/resources/config_template.toml,sha256=d3pofgIK5FxaRMELAI1qEsRcMD3GlYd87zZjDj9G9m0,3210
 pymodaq/resources/preset_default.xml,sha256=Dt8iWLwPPOPtcG00JCVP-mh-G7KC6B0YN8hd8RQdnNI,27256
@@ -437,8 +438,8 @@ pymodaq/utils/tcp_ip/__init__.py,sha256=1e_EK0AgvdoLAD_CSGGEaITZdy6OWCO7ih9IAIp7
 pymodaq/utils/tcp_ip/mysocket.py,sha256=StAWj8dzHeMnbLj68Sel81uWFy-YkKVNRnVf7gXrESI,3452
 pymodaq/utils/tcp_ip/serializer.py,sha256=oTQ24JNln_vRX4YADitTYiJplwFIdsta1ZDp6TOGMCA,27562
 pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=xIMTNgVW_rKK0yTi4FDNFLf85-Akb27Jz2LdrvOrP68,30660
-pymodaq-4.3.2.dist-info/METADATA,sha256=mpbKUYitkvphHcpbDoq-xnHedsXFQHmEclV9UCVyLgA,7657
-pymodaq-4.3.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-pymodaq-4.3.2.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
-pymodaq-4.3.2.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
-pymodaq-4.3.2.dist-info/RECORD,,
+pymodaq-4.3.4.dist-info/METADATA,sha256=gm5Fngee-a_FaJlJKKTtjEy8u1rlwxWHTiGBZgTvaRU,7657
+pymodaq-4.3.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq-4.3.4.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-4.3.4.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-4.3.4.dist-info/RECORD,,