pymodaq 5.0.5__tar.gz → 5.1.0a0__tar.gz

{pymodaq-5.0.5 → pymodaq-5.1.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymodaq
-Version: 5.0.5
+Version: 5.1.0a0
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -43,14 +43,15 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.8
-Requires-Dist: bayesian-optimization<2.0.0
+Requires-Dist: adaptive
+Requires-Dist: bayesian-optimization>=2.0
 Requires-Dist: easydict
 Requires-Dist: multipledispatch
 Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: pyleco>0.3; python_version >= '3.8'
-Requires-Dist: pymodaq-data>=5.0.18
+Requires-Dist: pymodaq-data>=5.0.21
 Requires-Dist: pymodaq-gui>=5.0.17
 Requires-Dist: pymodaq-plugin-manager>=0.0.17
 Requires-Dist: pymodaq-plugins-mock>=5.0.5

{pymodaq-5.0.5 → pymodaq-5.1.0a0}/pyproject.toml

@@ -33,7 +33,7 @@ classifiers = [
 dependencies = [
     "pymodaq_utils>=0.0.14",
     "pymodaq_gui>=5.0.17",
-    "pymodaq_data>=5.0.18",
+    "pymodaq_data>=5.0.21",
     "easydict",
     "multipledispatch",
     "numpy < 2.0.0",
@@ -50,7 +50,8 @@ dependencies = [
     "toml",
     "qtconsole",
     "pyleco>0.3; python_version>=\"3.8\"",
-    "bayesian-optimization<2.0.0",
+    "bayesian-optimization>=2.0",
+    "adaptive",
 ]
 
 
@@ -78,8 +79,7 @@ daq_move = "pymodaq.control_modules.daq_move:main"
 daq_scan = "pymodaq.extensions.daq_scan:main"
 daq_viewer = "pymodaq.control_modules.daq_viewer:main"
 dashboard = "pymodaq.dashboard:main"
-h5browser = "pymodaq.extensions.h5browser:main"
-parameter_example = "pymodaq.examples.parameter_ex:main"
+
 
 [project.urls]
 Homepage = "http://pymodaq.cnrs.fr"

{pymodaq-5.0.5 → pymodaq-5.1.0a0}/src/pymodaq/control_modules/daq_move.py

@@ -36,6 +36,8 @@ from pymodaq_gui.utils.utils import mkQApp
 
 from pymodaq.utils.h5modules import module_saving
 from pymodaq.control_modules.utils import ParameterControlModule
+from pymodaq.control_modules.thread_commands import (ThreadStatus, ThreadStatusMove, ControlToHardwareMove,
+                                                     UiToMainMove)
 from pymodaq.control_modules.daq_move_ui import DAQ_Move_UI, ThreadCommand
 from pymodaq.control_modules.move_utility_classes import (MoveCommand, DAQ_Move_base,
                                                           DataActuatorType, check_units,
@@ -43,7 +45,7 @@ from pymodaq.control_modules.move_utility_classes import (MoveCommand, DAQ_Move_
 
 
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
-from pymodaq.utils.leco.pymodaq_listener import MoveActorListener, LECOMoveCommands
+from pymodaq.utils.leco.pymodaq_listener import MoveActorListener, LECOMoveCommands, LECOCommands
 
 from pymodaq.utils.daq_utils import get_plugins
 from pymodaq import Q_, Unit
@@ -126,7 +128,7 @@ class DAQ_Move(ParameterControlModule):
         if len(ACTUATOR_TYPES) > 0:  # will be 0 if no valid plugins are installed
             self.actuator = kwargs.get('actuator', ACTUATOR_TYPES[0])
 
-        self.module_and_data_saver = module_saving.ActuatorSaver(self)
+        self.module_and_data_saver = module_saving.ActuatorTimeSaver(self)
 
         self._move_done_bool = True
 
@@ -157,36 +159,36 @@ class DAQ_Move(ParameterControlModule):
             * rel_value
             * show_config
         """
-        if cmd.command == 'init':
+        if cmd.command == UiToMainMove.INIT:
             self.init_hardware(cmd.attribute[0])
-        elif cmd.command == 'quit':
+        elif cmd.command == UiToMainMove.QUIT:
             self.quit_fun()
-        elif cmd.command == 'get_value':
+        elif cmd.command == UiToMainMove.GET_VALUE:
             self.get_actuator_value()
-        elif cmd.command == 'loop_get_value':
+        elif cmd.command == UiToMainMove.LOOP_GET_VALUE:
             self.get_continuous_actuator_value(cmd.attribute)
-        elif cmd.command == 'find_home':
+        elif cmd.command == UiToMainMove.FIND_HOME:
             self.move_home()
-        elif cmd.command == 'stop':
+        elif cmd.command == UiToMainMove.STOP:
             self.stop_motion()
-        elif cmd.command == 'move_abs':
+        elif cmd.command == UiToMainMove.MOVE_ABS:
             data_act: DataActuator = cmd.attribute
             if not Unit(data_act.units).is_compatible_with(self.units) and data_act.units != '':
                 data_act.force_units(self.units)
             self.move_abs(data_act)
-        elif cmd.command == 'move_rel':
+        elif cmd.command == UiToMainMove.MOVE_REL:
             data_act: DataActuator = cmd.attribute
             if not Unit(data_act.units).is_compatible_with(self.units) and data_act.units != '':
                 data_act.force_units(self.units)
             self.move_rel(data_act)
-        elif cmd.command == 'show_log':
+        elif cmd.command == UiToMainMove.SHOW_LOG:
             self.show_log()
-        elif cmd.command == 'show_config':
+        elif cmd.command == UiToMainMove.SHOW_CONFIG:
             self.config = self.show_config(self.config)
             self.ui.config = self.config
-        elif cmd.command == 'actuator_changed':
+        elif cmd.command == UiToMainMove.ACTUATOR_CHANGED:
             self.actuator = cmd.attribute
-        elif cmd.command == 'rel_value':
+        elif cmd.command == UiToMainMove.REL_VALUE:
             self._relative_value = cmd.attribute
 
     @property
@@ -203,12 +205,13 @@ class DAQ_Move(ParameterControlModule):
             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):
+    def append_data(self, dte: Optional[DataToExport] = None,
+                    where: Union[Node, str, None] = None):
         """Appends current DataToExport to an ActuatorEnlargeableSaver
 
         Parameters
         ----------
-        data
+        dte: DataToExport, optional
         where: Node or str
         See Also
         --------
@@ -245,7 +248,7 @@ class DAQ_Move(ParameterControlModule):
         """Stop any motion
         """
         try:
-            self.command_hardware.emit(ThreadCommand(command="stop_motion"))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.STOP_MOTION))
         except Exception as e:
             self.logger.exception(str(e))
 
@@ -294,8 +297,9 @@ class DAQ_Move(ParameterControlModule):
                 self._move_done_bool = False
                 self._target_value = value
                 self.update_status("Moving")
-                self.command_hardware.emit(ThreadCommand(command="reset_stop_motion"))
-                self.command_hardware.emit(ThreadCommand(command="move_abs", attribute=[value]))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.RESET_STOP_MOTION))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.MOVE_ABS,
+                                                         attribute=[value]))
 
         except Exception as e:
             self.logger.exception(str(e))
@@ -314,8 +318,8 @@ class DAQ_Move(ParameterControlModule):
                 self.ui.move_done = False
             self._move_done_bool = False
             self.update_status("Moving")
-            self.command_hardware.emit(ThreadCommand(command="reset_stop_motion"))
-            self.command_hardware.emit(ThreadCommand(command="move_home"))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.RESET_STOP_MOTION))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.MOVE_HOME))
 
         except Exception as e:
             self.logger.exception(str(e))
@@ -342,8 +346,9 @@ class DAQ_Move(ParameterControlModule):
             self._move_done_bool = False
             self._target_value = self._current_value + rel_value
             self.update_status("Moving")
-            self.command_hardware.emit(ThreadCommand(command="reset_stop_motion"))
-            self.command_hardware.emit(ThreadCommand(command="move_rel", attribute=[rel_value]))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.RESET_STOP_MOTION))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.MOVE_REL,
+                                                     attribute=[rel_value]))
 
         except Exception as e:
             self.logger.exception(str(e))
@@ -372,7 +377,7 @@ class DAQ_Move(ParameterControlModule):
         """ Init or desinit the selected instrument plugin class """
         if not do_init:
             try:
-                self.command_hardware.emit(ThreadCommand(command="close"))
+                self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.CLOSE))
                 if self.ui is not None:
                     self.ui.actuator_init = False
             except Exception as e:
@@ -390,9 +395,10 @@ 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(ControlToHardwareMove.INI_STAGE,
+                                  attribute=[
+                                      self.settings.child('move_settings').saveState(),
+                                      self.controller]))
             except Exception as e:
                 self.logger.exception(str(e))
 
@@ -432,6 +438,7 @@ class DAQ_Move(ParameterControlModule):
         self.update_status("Timeout occurred")
         self.wait_position_flag = False
 
+
     @Slot(ThreadCommand)
     def thread_status(self, status: ThreadCommand):  # general function to get datas/infos from all threads back to the main
         """Get back info (using the ThreadCommand object) from the hardware
@@ -457,7 +464,7 @@ class DAQ_Move(ParameterControlModule):
 
         super().thread_status(status, 'move')
 
-        if status.command == "ini_stage":
+        if status.command == ThreadStatusMove.INI_STAGE:
             self.update_status(f"Stage initialized: {status.attribute['initialized']} "
                                f"info: {status.attribute['info']}")
             if status.attribute['initialized']:
@@ -471,7 +478,7 @@ class DAQ_Move(ParameterControlModule):
                 self.get_actuator_value()
             self.init_signal.emit(self._initialized_state)
 
-        elif status.command == "get_actuator_value" or status.command == 'check_position':
+        elif status.command == ThreadStatusMove.GET_ACTUATOR_VALUE or status.command == 'check_position':
             data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
@@ -485,7 +492,7 @@ class DAQ_Move(ParameterControlModule):
             if self.settings['main_settings', 'leco', 'leco_connected'] and self._send_to_tcpip:
                 self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.POSITION, data_act))
 
-        elif status.command == "move_done":
+        elif status.command == ThreadStatusMove.MOVE_DONE:
             data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
@@ -498,17 +505,17 @@ class DAQ_Move(ParameterControlModule):
             if self.settings.child('main_settings', 'leco', 'leco_connected').value() and self._send_to_tcpip:
                 self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.MOVE_DONE, data_act))
 
-        elif status.command == 'outofbounds':
+        elif status.command == ThreadStatusMove.OUT_OF_BOUNDS:
             self.bounds_signal.emit(True)
 
-        elif status.command == 'set_allowed_values':
+        elif status.command == ThreadStatusMove.SET_ALLOWED_VALUES:
             if self.ui is not None:
                 self.ui.set_abs_spinbox_properties(**status.attribute)
 
-        elif status.command == 'stop':
+        elif status.command == ThreadStatusMove.STOP:
             self.stop_motion()
 
-        elif status.command == 'units':
+        elif status.command == ThreadStatusMove.UNITS:
             self.units = status.attribute
 
     def _check_data_type(self, data_act: Union[list[np.ndarray], float, DataActuator]) -> DataActuator:
@@ -533,7 +540,7 @@ class DAQ_Move(ParameterControlModule):
         Returns nothing but the  `move_done_signal` will be send once the action is done
         """
         try:
-            self.command_hardware.emit(ThreadCommand(command="get_actuator_value"))
+            self.command_hardware.emit(ThreadCommand(ControlToHardwareMove.GET_ACTUATOR_VALUE))
 
         except Exception as e:
             self.logger.exception(str(e))
@@ -663,35 +670,36 @@ class DAQ_Move(ParameterControlModule):
         super().connect_tcp_ip(params_state=self.settings.child('move_settings'),
                                client_type="ACTUATOR")
 
+    def connect_leco(self, connect: bool) -> None:
+        super().connect_leco(connect)
+
+
+
     @Slot(ThreadCommand)
     def process_tcpip_cmds(self, status: ThreadCommand) -> None:
         if super().process_tcpip_cmds(status=status) is None:
             return
-        if 'move_abs' in status.command:
-            self.move_abs(status.attribute[0], send_to_tcpip=True)
+        if LECOMoveCommands.MOVE_ABS == status.command:
+            self.move_abs(status.attribute, send_to_tcpip=True)
 
-        elif 'move_rel' in status.command:
-            self.move_rel(status.attribute[0], send_to_tcpip=True)
+        elif LECOMoveCommands.MOVE_REL == status.command:
+            self.move_rel(status.attribute, send_to_tcpip=True)
 
-        elif 'move_home' in status.command:
+        elif LECOMoveCommands.MOVE_HOME == status.command:
             self.move_home(send_to_tcpip=True)
 
         elif 'check_position' in status.command:
             deprecation_msg('check_position is deprecated, you should use get_actuator_value')
             self._send_to_tcpip = True
-            self.command_hardware.emit(ThreadCommand('get_actuator_value', ))
+            self.get_actuator_value()
 
-        elif 'get_actuator_value' in status.command:
+        elif LECOMoveCommands.GET_ACTUATOR_VALUE in status.command:
             self._send_to_tcpip = True
-            self.command_hardware.emit(ThreadCommand('get_actuator_value', ))
+            self.get_actuator_value()
+
+        elif status.command == LECOMoveCommands.STOP:
+            self.stop_motion()
 
-        elif status.command == 'set_info':
-            path_in_settings = status.attribute[0]
-            param_as_xml = status.attribute[1]
-            param_dict = ioxml.XML_string_to_parameter(param_as_xml)[0]
-            param_tmp = Parameter.create(**param_dict)
-            param = self.settings.child('move_settings', *path_in_settings[1:])
-            param.restoreState(param_tmp.saveState())
 
 
 class DAQ_Move_Hardware(QObject):
@@ -791,7 +799,8 @@ class DAQ_Move_Hardware(QObject):
             status.controller = self.hardware.controller
             self.hardware.move_done_signal.connect(self.move_done)
             if status.initialized:
-                self.status_sig.emit(ThreadCommand('get_actuator_value', [self.get_actuator_value()]))
+                self.status_sig.emit(ThreadCommand(ThreadStatusMove.GET_ACTUATOR_VALUE,
+                                                   self.get_actuator_value()))
 
             return status
         except Exception as e:
@@ -837,7 +846,7 @@ class DAQ_Move_Hardware(QObject):
             --------
             DAQ_utils.ThreadCommand
         """
-        self.status_sig.emit(ThreadCommand("move_done", pos))
+        self.status_sig.emit(ThreadCommand(ThreadStatusMove.MOVE_DONE, pos))
 
     def move_home(self):
         """
@@ -852,7 +861,8 @@ class DAQ_Move_Hardware(QObject):
         """Send the move_done signal back to the main class
         """
         self._current_value = pos
-        self.status_sig.emit(ThreadCommand(command="move_done", attribute=pos))
+        self.status_sig.emit(ThreadCommand(command=ThreadStatusMove.MOVE_DONE,
+                                           attribute=pos))
 
     @Slot(ThreadCommand)
     def queue_command(self, command: ThreadCommand):
@@ -881,31 +891,34 @@ class DAQ_Move_Hardware(QObject):
         """
         try:
             logger.debug(f'Threadcommand {command.command} sent to {self.title}')
-            if command.command == "ini_stage":
+            if command.command == ControlToHardwareMove.INI_STAGE:
                 status: edict = self.ini_stage(*command.attribute)
-                self.status_sig.emit(ThreadCommand(command=command.command, attribute=status))
+                self.status_sig.emit(ThreadCommand(command=ThreadStatusMove.INI_STAGE,
+                                                   attribute=status))
 
-            elif command.command == "close":
+            elif command.command == ControlToHardwareMove.CLOSE:
                 status = self.close()
-                self.status_sig.emit(ThreadCommand(command=command.command, attribute=[status]))
+                self.status_sig.emit(ThreadCommand(command=ThreadStatus.CLOSE,
+                                                   attribute=[status]))
 
-            elif command.command == "move_abs":
+            elif command.command == ControlToHardwareMove.MOVE_ABS:
                 self.move_abs(*command.attribute)
 
-            elif command.command == "move_rel":
+            elif command.command == ControlToHardwareMove.MOVE_REL:
                 self.move_rel(*command.attribute)
 
-            elif command.command == "move_home":
+            elif command.command == ControlToHardwareMove.MOVE_HOME:
                 self.move_home()
 
-            elif command.command == "get_actuator_value":
+            elif command.command == ControlToHardwareMove.GET_ACTUATOR_VALUE:
                 pos = self.get_actuator_value()
-                self.status_sig.emit(ThreadCommand('get_actuator_value', [pos]))
+                self.status_sig.emit(ThreadCommand(ThreadStatusMove.GET_ACTUATOR_VALUE,
+                                                   pos))
 
-            elif command.command == "stop_motion":
+            elif command.command == ControlToHardwareMove.STOP_MOTION:
                 self.stop_motion()
 
-            elif command.command == "reset_stop_motion":
+            elif command.command == ControlToHardwareMove.RESET_STOP_MOTION:
                 self.motion_stoped = False
 
             else:  # custom commands for particular plugins (see spectrometer module 'get_spectro_wl' for instance)

{pymodaq-5.0.5 → pymodaq-5.1.0a0}/src/pymodaq/control_modules/daq_move_ui.py

@@ -24,7 +24,7 @@ from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
 
 from pymodaq.control_modules.utils import ControlModuleUI
 from pymodaq.utils.data import DataToExport, DataActuator
-
+from pymodaq.control_modules.thread_commands import UiToMainMove
 
 config = Config()
 
@@ -308,14 +308,15 @@ class DAQ_Move_UI(ControlModuleUI):
         self.connect_action('show_settings', lambda show: self.settings_ui.setVisible(show))
         self.connect_action('show_graph', lambda show: self.graph_ui.setVisible(show))
 
-        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand('quit', )))
+        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.QUIT, )))
         self.connect_action('refresh_value',
-                            lambda do_refresh: self.command_sig.emit(ThreadCommand('loop_get_value', do_refresh)))
+                            lambda do_refresh: self.command_sig.emit(ThreadCommand(UiToMainMove.LOOP_GET_VALUE,
+                                                                                   do_refresh)))
         self.connect_action('move_abs', lambda: self.emit_move_abs(self.abs_value_sb))
         self.connect_action('move_abs_2', lambda: self.emit_move_abs(self.abs_value_sb_2))
-        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand('show_log', )))
-        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand('stop', )))
-        self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand('show_config', )))
+        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.SHOW_LOG, )))
+        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.STOP, )))
+        self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.SHOW_CONFIG, )))
 
         self.move_abs_pb.clicked.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
         self.abs_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb))
@@ -324,20 +325,20 @@ class DAQ_Move_UI(ControlModuleUI):
 
 
         self.rel_value_sb.valueChanged.connect(lambda: self.command_sig.emit(
-            ThreadCommand('rel_value', self.rel_value_sb.value())))
+            ThreadCommand(UiToMainMove.REL_VALUE, self.rel_value_sb.value())))
         self.move_rel_plus_pb.clicked.connect(lambda: self.emit_move_rel('+'))
         self.move_rel_minus_pb.clicked.connect(lambda: self.emit_move_rel('-'))
         self.rel_value_sb.shortcut["Ctrl+E"].activated.connect(lambda: self.emit_move_rel('+'))
         self.rel_value_sb.shortcut["Ctrl+Shift+E"].activated.connect(lambda: self.emit_move_rel('-'))
 
-        self.find_home_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('find_home', )))
-        self.stop_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('stop', )))
-        self.get_value_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand('get_value', )))
+        self.find_home_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.FIND_HOME, )))
+        self.stop_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.STOP, )))
+        self.get_value_pb.clicked.connect(lambda: self.command_sig.emit(ThreadCommand(UiToMainMove.GET_VALUE, )))
 
         self.ini_actuator_pb.clicked.connect(self.send_init)
 
         self.actuators_combo.currentTextChanged.connect(
-            lambda act: self.command_sig.emit(ThreadCommand('actuator_changed', act)))
+            lambda act: self.command_sig.emit(ThreadCommand(UiToMainMove.ACTUATOR_CHANGED, act)))
 
     def do_init(self, do_init=True):
         """Programmatically press the Init button
@@ -352,17 +353,17 @@ class DAQ_Move_UI(ControlModuleUI):
 
     def send_init(self, checked):
         self.actuators_combo.setEnabled(not checked)
-        self.command_sig.emit(ThreadCommand('init', [self.ini_actuator_pb.isChecked(),
+        self.command_sig.emit(ThreadCommand(UiToMainMove.INIT, [self.ini_actuator_pb.isChecked(),
                                                      self.actuators_combo.currentText()]))
 
     def emit_move_abs(self, spinbox):
         spinbox.editingFinished.emit()
-        self.command_sig.emit(ThreadCommand('move_abs', DataActuator(data=spinbox.value(),
+        self.command_sig.emit(ThreadCommand(UiToMainMove.MOVE_ABS, DataActuator(data=spinbox.value(),
                                                                      units=self._unit)))
 
     def emit_move_rel(self, sign):
         self.command_sig.emit(ThreadCommand(
-            'move_rel',
+            UiToMainMove.MOVE_REL,
             DataActuator(data=self.rel_value_sb.value() * (1 if sign == '+' else -1),
                          units=self._unit)))
 
@@ -384,7 +385,7 @@ def main(init_qt=True):
     
     def print_command_sig(cmd_sig):
         print(cmd_sig)
-        if cmd_sig.command == 'init':
+        if cmd_sig.command == UiToMainMove.INIT:
             prog.enable_move_buttons(True)
         
     prog.command_sig.connect(print_command_sig)