pymodaq 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymodaq/examples/qt_less_standalone_module.py

@@ -0,0 +1,128 @@
+"""
+Example how to create an actuator or detector module, which does not require Qt, nor any GUI functionality.
+
+You can connect to this qtless module with a PyMoDAQ LECODirector module (the detector or actuator version, both are preinstalled),
+as if it were any pymodaq module.
+
+This example works best with an Actuator Director Module as it has fake movements, but does not return any detector value.
+In this example, the name is "qt_less" (defined in the final if clause), which you have to give as the "actor" argument to the Director module.
+
+Add any code in the methods defined below, for example instrument access and execute the file.
+For remote control, you need to start a Coordinator, as described for remote control via LECO.
+"""
+
+import logging
+from time import sleep
+from typing import List, Union
+
+from pyleco.utils.listener import Listener
+
+
+class QtLessModule:
+    """Some module doing things without Qt.
+    
+    You can run an instance of this class anywhere in your LECO network.
+    Then you can control this instance with a PyMoDAQ LECODirectorModule (in mock modules) as if it were a PyMoDAQ module.
+
+    Just add any logic you wish to the methods below.
+    """
+
+    def __init__(self, name: str, host: str = "localhost", **kwargs) -> None:
+        super().__init__()
+        self.listener = Listener(name=name, host=host, timeout=1, **kwargs)
+        self._fake_position = 0
+        self.start_listen()
+        self._stored = []
+
+    def start_listen(self) -> None:
+        """Start to listen on incoming commands."""
+        self.listener.start_listen()
+        self.communicator = self.listener.get_communicator()
+        self.register_rpc_methods()
+
+    def register_rpc_methods(self) -> None:
+        """Make the following methods available via LECO."""
+        register_rpc_method = self.communicator.register_rpc_method
+        register_rpc_method(self.set_info)
+        register_rpc_method(self.send_data)
+        register_rpc_method(self.move_abs)
+        register_rpc_method(self.move_rel)
+        register_rpc_method(self.move_home)
+        register_rpc_method(self.get_actuator_value)
+        register_rpc_method(self.stop_motion)
+        register_rpc_method(self.set_remote_name)
+
+    def stop_listen(self) -> None:
+        """Stop to listen on incoming commands."""
+        self.listener.stop_listen()
+
+    # smethods for being remote controlled
+    # these methods are executed and cannot talk to the controlling module directly.
+    # if you need to send a response (for example with a value) you have to store the information and
+    # send it after these methods have been executed.
+    def set_remote_name(self, name: str) -> None:
+        """Define what the name of the remote for answers is."""
+        self.remote_name = name
+
+    # generic commands
+    def set_info(self, path: List[str], param_dict_str: str) -> None:
+        print("set_info", path, param_dict_str)
+
+    # detector commands
+    def send_data(self, grabber_type: str = "") -> None:
+        print("send_data")
+
+    # actuator commands
+    def move_abs(self, position: Union[float, str]) -> None:
+        print("move_abs", position)
+        self._fake_position = float(position)
+
+    def move_rel(self, position: Union[float, str]) -> None:
+        print("move_rel", position)
+        self._fake_position += float(position)
+
+    def move_home(self) -> None:
+        self._fake_position = 0
+        print("move_home")
+
+    def get_actuator_value(self) -> None:
+        """Request that the actuator value is sent later on."""
+        # according to DAQ_Move, this supersedes "check_position"
+        print("get_actuator_value")
+        # send the actuator position after this method has finished execution.
+        # this method sends the result to the controlling control module.
+        self.send_later(
+            receiver=self.remote_name,
+            method="set_position",
+            position=self._fake_position,
+        )
+
+    def stop_motion(self,) -> None:
+        # not implemented in DAQ_Move!
+        print("stop_motion")
+
+    # end of methods for being remote controlled
+
+    def send_later(self, receiver, method, **kwargs):
+        """Store information to send it later."""
+        self._stored.append((receiver, method, kwargs))
+
+    def send_stored(self):
+        """Send messages stored for later sending."""
+        while self._stored:
+            receiver, method, kwargs = self._stored.pop()
+            self.communicator.ask_rpc(receiver=receiver, method=method, **kwargs)
+
+
+if __name__ == "__main__":
+    print("listening endlessly as 'qt_less'")
+    log = logging.getLogger()
+    log.addHandler(logging.StreamHandler())
+    # log.setLevel(logging.DEBUG)
+    m = QtLessModule("qt_less")
+    try:
+        while True:
+            sleep(0.1)
+            m.send_stored()
+    except KeyboardInterrupt:
+        m.stop_listen()

pymodaq/extensions/bayesian/bayesian_optimisation.py

@@ -9,12 +9,16 @@ import numpy as np
 from pymodaq.utils.data import DataToExport, DataToActuators, DataCalculated, DataActuator
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq_utils import utils
-from pymodaq_utils import config as configmod
+from pymodaq_utils import config as config_mod
+from pymodaq_utils.enums import BaseEnum
+
+from pymodaq_gui.config import ConfigSaverLoader
 from pymodaq_utils.logger import set_logger, get_module_name
 
 from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
 from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
 from pymodaq_gui.utils import QLED
+from pymodaq_gui.utils.utils import mkQApp
 from pymodaq_gui import utils as gutils
 from pymodaq_gui.parameter import utils as putils
 from pymodaq_gui.h5modules.saving import H5Saver
@@ -27,15 +31,24 @@ from pymodaq.extensions.bayesian.utils import (get_bayesian_models, BayesianMode
                                                UtilityParameters, StopType, StoppingParameters)
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
 from pymodaq.extensions.bayesian.utils import BayesianConfig
-
+from pymodaq.extensions.utils import CustomExt
 
 EXTENSION_NAME = 'BayesianOptimisation'
 CLASS_NAME = 'BayesianOptimisation'
 
 logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
+
 
+class DataNames(BaseEnum):
+    Fitness = 0
+    Individual = 1
+    ProbedData = 2
+    Actuators = 3
+    Kappa = 4
 
-class BayesianOptimisation(gutils.CustomApp):
+
+class BayesianOptimisation(CustomExt):
     """ PyMoDAQ extension of the DashBoard to perform the optimization of a target signal
     taken form the detectors as a function of one or more parameters controlled by the actuators.
     """
@@ -112,7 +125,7 @@ class BayesianOptimisation(gutils.CustomApp):
         self.setup_ui()
 
         self.bayesian_config = BayesianConfig()
-        self.mainsettings_saver_loader = configmod.ConfigSaverLoader(
+        self.mainsettings_saver_loader = ConfigSaverLoader(
             self.settings.child('main_settings'), self.bayesian_config)
 
         self.h5temp: H5Saver = None
@@ -176,7 +189,7 @@ class BayesianOptimisation(gutils.CustomApp):
             params = getattr(model_class, 'params')
             self.settings.child('models', 'model_params').addChildren(params)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         '''
         to be subclassed
         create menu for actions contained into the self.actions_manager, for instance:
@@ -450,20 +463,20 @@ class BayesianOptimisation(gutils.CustomApp):
     def process_output(self, dte: DataToExport):
 
         self.enl_index += 1
-        dwa_kappa = dte.remove(dte.get_data_from_name('kappa'))
+        dwa_kappa = dte.remove(dte.get_data_from_name(DataNames.Kappa.name))
         self.settings.child('main_settings', 'utility', 'kappa_actual').setValue(
             float(dwa_kappa[0][0])
         )
 
-        dwa_data = dte.remove(dte.get_data_from_name('ProbedData'))
-        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name('Actuators'))
+        dwa_data = dte.remove(dte.get_data_from_name(DataNames.ProbedData.name))
+        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name(DataNames.Actuators.name))
         self.viewer_observable.show_data(dte)
 
         # dwa_observations = self.algorithm.get_dwa_obervations(
         #     self.modules_manager.selected_actuators_name)
         self.model_class.update_plots()
 
-        best_individual = dte.get_data_from_name('Individual')
+        best_individual = dte.get_data_from_name(DataNames.Individual.name)
         best_indiv_as_list = [float(best_individual[ind][0]) for ind in range(len(best_individual))]
 
 
@@ -582,7 +595,7 @@ class OptimisationRunner(QtCore.QObject):
                                                     polling=sync_acts)
 
                 # Do the evaluation (measurements)
-                self.det_done_datas = self.modules_manager.grab_datas()
+                self.det_done_datas = self.modules_manager.grab_data()
                 self.input_from_dets = self.model_class.convert_input(self.det_done_datas)
 
                 # Run the algo internal mechanic
@@ -591,17 +604,17 @@ class OptimisationRunner(QtCore.QObject):
                 dte = DataToExport('algo',
                                    data=[self.individual_as_data(
                                        np.array([self.optimisation_algorithm.best_fitness]),
-                                       'Fitness'),
+                                       DataNames.Fitness.name),
                                        self.individual_as_data(
                                            self.optimisation_algorithm.best_individual,
-                                           'Individual'),
-                                       DataCalculated('ProbedData',
+                                           DataNames.Individual.name),
+                                       DataCalculated(DataNames.ProbedData.name,
                                                       data=[np.array([self.input_from_dets])],
                                                       ),
-                                       self.output_to_actuators.merge_as_dwa('Data0D',
-                                                                             'Actuators'),
+                                       self.output_to_actuators.merge_as_dwa(
+                                           'Data0D', DataNames.Actuators.name),
                                        DataCalculated(
-                                           'kappa',
+                                           DataNames.Kappa.name,
                                            data=[
                                                np.array([self.optimisation_algorithm.kappa])])
                                          ])
@@ -638,10 +651,7 @@ def main(init_qt=True):
     from pymodaq.utils.daq_utils import get_set_preset_path
 
     if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
+        app = mkQApp("PyMoDAQ Dashboard")
 
     from pymodaq.dashboard import DashBoard
 
@@ -649,7 +659,6 @@ def main(init_qt=True):
     area = gutils.dock.DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
 
     dashboard = DashBoard(area)
     daq_scan = None

pymodaq/extensions/bayesian/utils.py

@@ -116,10 +116,13 @@ class BayesianAlgorithm:
 
     @property
     def best_individual(self) -> Union[np.ndarray, None]:
-        max_param = self._algo.max.get('params', None)
-        if max_param is None:
+        if self._algo.max is None:
             return None
-        return self._algo.space.params_to_array(max_param)
+        else:
+            max_param = self._algo.max.get('params', None)
+            if max_param is None:
+                return None
+            return self._algo.space.params_to_array(max_param)
 
     def stopping(self, ind_iter: int, stopping_parameters: StoppingParameters):
         if ind_iter >= stopping_parameters.niter:

pymodaq/extensions/daq_logger/__init__.py

@@ -0,0 +1 @@
+from .daq_logger import main

pymodaq/extensions/daq_logger/daq_logger.py

@@ -12,7 +12,6 @@ import datetime
 from typing import TYPE_CHECKING, Union
 
 from pymodaq_utils.logger import set_logger, get_module_name
-from pymodaq_gui.utils.custom_app import CustomApp
 from pymodaq_gui.utils.dock import Dock, DockArea
 from pymodaq_utils.config import Config
 from pymodaq_gui.parameter import ioxml
@@ -26,7 +25,7 @@ from pymodaq_gui.utils.widgets import QLED
 from pymodaq.extensions.daq_logger.h5logging import H5Logger
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.utils.data import DataActuator, DataToExport
-
+from pymodaq.extensions.utils import CustomExt
 
 if TYPE_CHECKING:
     from pymodaq.dashboard import DashBoard
@@ -51,7 +50,7 @@ if is_sql:
     LOG_TYPES.append('SQL DataBase')
 
 
-class DAQ_Logger(CustomApp):
+class DAQ_Logger(CustomExt):
     """
     Main class initializing a DAQ_Logger module
     """
@@ -147,10 +146,10 @@ class DAQ_Logger(CustomApp):
 
         self._actions['infos'].connect_to(self.dashboard.show_log)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         """
         """
-        file_menu = self.mainwindow.menuBar().addMenu('File')
+        file_menu = menubar.addMenu('File')
         self.affect_to('infos', file_menu)
 
     def value_changed(self, param):

pymodaq/extensions/daq_scan.py

@@ -29,18 +29,16 @@ from pymodaq_gui.parameter import ioxml
 from pymodaq_gui.plotting.data_viewers import ViewersEnum
 from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
 from pymodaq_gui.plotting.navigator import Navigator
-
 from pymodaq_gui.messenger import messagebox
 from pymodaq_gui import utils as gutils
 from pymodaq_gui.h5modules.saving import H5Saver
 
-from pymodaq.utils.scanner.scanner import Scanner, scanner_factory  #, adaptive, adaptive_losses
+from pymodaq.utils.scanner.scanner import Scanner
 from pymodaq.utils.managers.batchscan_manager import BatchScanner
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
 from pymodaq.extensions.daq_scan_ui import DAQScanUI
 from pymodaq.utils.h5modules import module_saving
-
 from pymodaq.utils.scanner.scan_selector import ScanSelector, SelectorItem
 from pymodaq.utils.data import DataActuator
 
@@ -88,7 +86,12 @@ class DAQScan(QObject, ParameterManager):
             {'title': 'Timeout (ms)', 'name': 'timeout', 'type': 'int', 'value': 10000},
         ]},
         {'title': 'Scan options', 'name': 'scan_options', 'type': 'group', 'children': [
-            {'title': 'Naverage:', 'name': 'scan_average', 'type': 'int', 'value': 1, 'min': 1},
+            {'title': 'Naverage:', 'name': 'scan_average', 'type': 'int',
+             'value': config('scan', 'Naverage'), 'min': 1},
+            {'title': 'Plot on top:', 'name': 'average_on_top', 'type': 'bool',
+             'value': config('scan', 'average_on_top'),
+             'tip': 'At the second iteration will plot the averaged scan on top (True) of the current one'
+                    'or in a second panel (False)'},
         ]},
 
         {'title': 'Plotting options', 'name': 'plot_options', 'type': 'group', 'children': [
@@ -441,7 +444,7 @@ class DAQScan(QObject, ParameterManager):
         if not os.path.isdir(self.h5saver.settings['base_path']):
             os.mkdir(self.h5saver.settings['base_path'])
         filename = gutils.file_io.select_file(self.h5saver.settings['base_path'], save=True, ext='h5')
-        self.h5saver.h5_file.copy_file(str(filename))
+        self.h5saver.h5_file.copy_file(str(filename), overwrite=True)
 
     def save_metadata(self, node, type_info='dataset_info'):
         """
@@ -635,6 +638,10 @@ class DAQScan(QObject, ParameterManager):
             viewers_enum.extend([ViewersEnum('Data1D').increase_dim(self.scanner.n_axes)
                                  for _ in range(len(self.settings['plot_options', 'plot_1d']['selected']))])
             data_names.extend(self.settings['plot_options', 'plot_1d']['selected'][:])
+        if not self.settings['scan_options', 'average_on_top']:
+
+            viewers_enum = viewers_enum + viewers_enum
+            data_names = data_names + [f'{data_name}_averaged' for data_name in data_names]
         self.live_plotter.prepare_viewers(viewers_enum, viewers_name=data_names)
 
     def update_status(self, txt: str, wait_time=0):
@@ -674,6 +681,7 @@ class DAQScan(QObject, ParameterManager):
             self.ui.set_scan_step_average(status.attribute[1] + 1)
 
         elif status.command == "Scan_done":
+
             self.modules_manager.reset_signals()
             self.live_timer.stop()
             self.ui.set_scan_done()
@@ -738,6 +746,7 @@ class DAQScan(QObject, ParameterManager):
             self.live_plotter.load_plot_data(group_0D=self.settings['plot_options', 'group0D'],
                                              average_axis=average_axis,
                                              average_index=self.ind_average,
+                                             separate_average= not self.settings['scan_options', 'average_on_top'],
                                              target_at=self.scanner.positions[self.ind_scan],
                                              last_step=(self.ind_scan ==
                                                         self.scanner.positions.size - 1 and
@@ -774,6 +783,8 @@ class DAQScan(QObject, ParameterManager):
                     text="There are not enough or too much selected move modules for this scan")
                 return False
 
+            ## TODO the stuff about adaptive scans have to be moved into a dedicated extension. M
+            ## Most similat to the Bayesian one!
             if self.scanner.scan_sub_type == 'Adaptive':
                 #todo include this in scanners objects for the adaptive scanners
                 if len(self.modules_manager.get_selected_probed_data('0D')) == 0:
@@ -862,9 +873,15 @@ class DAQScan(QObject, ParameterManager):
             self.save_metadata(scan_node, 'scan_info')
 
             self._init_live()
+            Naverage = self.settings['scan_options', 'scan_average']
+            if Naverage > 1:
+                scan_shape = [Naverage]
+                scan_shape.extend(self.scanner.get_scan_shape())
+            else:
+                scan_shape = self.scanner.get_scan_shape()
             for det in self.modules_manager.detectors:
                 det.module_and_data_saver = (
-                    module_saving.DetectorExtendedSaver(det, self.scanner.get_scan_shape()))
+                    module_saving.DetectorExtendedSaver(det, scan_shape))
             self.module_and_data_saver.h5saver = self.h5saver  # force the update as the h5saver ill also be set on each detectors
 
             # mandatory to deal with multithreads
@@ -1044,7 +1061,7 @@ class DAQScanAcquisition(QObject):
 
     def start_acquisition(self):
         try:
-            #todo hoaw to apply newlayout to adaptive mode?
+            #todo hoaw to apply newlayout to adaptive mode? => cannot has to be a new extension
 
             self.modules_manager.connect_actuators()
             self.modules_manager.connect_detectors()
@@ -1116,6 +1133,7 @@ class DAQScanAcquisition(QObject):
                     # daq_scan wait time
                     QThread.msleep(self.scan_settings.child('time_flow', 'wait_time').value())
 
+            self.modules_manager.timeout_signal.disconnect()
             self.modules_manager.connect_actuators(False)
             self.modules_manager.connect_detectors(False)
 
@@ -1123,6 +1141,7 @@ class DAQScanAcquisition(QObject):
                                                      attribute="Acquisition has finished"))
             self.status_sig.emit(utils.ThreadCommand("Scan_done"))
 
+
         except Exception as e:
             logger.exception(str(e))
 
@@ -1158,7 +1177,8 @@ class DAQScanAcquisition(QObject):
             full_names: list = self.scan_settings['plot_options', 'plot_0d']['selected'][:]
             full_names.extend(self.scan_settings['plot_options', 'plot_1d']['selected'][:])
             data_temp = det_done_datas.get_data_from_full_names(full_names, deepcopy=False)
-            data_temp = data_temp.get_data_with_naxes_lower_than(2-len(indexes))  # maximum Data2D included nav indexes
+            n_nav_axis_selection = 2-len(indexes) + 1 if self.Naverage > 1 else 2-len(indexes)
+            data_temp = data_temp.get_data_with_naxes_lower_than(n_nav_axis_selection)  # maximum Data2D included nav indexes
 
             self.scan_data_tmp.emit(ScanDataTemp(self.ind_scan, indexes, data_temp))
 

pymodaq/extensions/daq_scan_ui.py

@@ -38,9 +38,10 @@ class DAQScanUI(CustomApp, ViewerDispatcher):
     def __init__(self, parent):
         CustomApp.__init__(self, parent)
         self.setup_docks()
-        ViewerDispatcher.__init__(self, self.dockarea, title='Scanner', next_to_dock=self.dock_command)
+        ViewerDispatcher.__init__(self, self.dockarea, title='Scanner',
+                                  next_to_dock=self.dock_command)
 
-        self.setup_menu()
+        self.setup_menu(self._menubar)
         self.setup_actions()
         self.connect_things()
 
@@ -83,13 +84,10 @@ class DAQScanUI(CustomApp, ViewerDispatcher):
         self.connect_action('navigator', lambda: self.command_sig.emit(ThreadCommand('navigator')))
         self.connect_action('batch', lambda: self.command_sig.emit(ThreadCommand('batch')))
 
-    def setup_menu(self):
-        self.menubar = QtWidgets.QMenuBar()
-        self.menubar.setMaximumHeight(30)
-        self.mainwindow.setMenuBar(self.menubar)
-        self.file_menu = self.menubar.addMenu('File')
-        self._extensions_menu = self.menubar.addMenu('Extensions')
-        self.action_menu = self.menubar.addMenu('Actions')
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
+        self.file_menu = menubar.addMenu('File')
+        self._extensions_menu = menubar.addMenu('Extensions')
+        self.action_menu = menubar.addMenu('Actions')
 
     def setup_docks(self):
         self.dock_command = Dock('Scan Command')

pymodaq/extensions/pid/__init__.py

@@ -3,7 +3,6 @@ from pathlib import Path
 
 from pymodaq_utils.logger import set_logger, get_module_name
 
-
 logger = set_logger('move_plugins', add_to_console=False)
 
 

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,32 +1,30 @@
-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
+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'
-    is_multiaxes = True
-    stage_names = []
+    _controller_units = ''
+    data_actuator_type = DataActuatorType.DataActuator
+    is_multiaxes = False
+    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):
@@ -38,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.controller = controller
+
+        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']))