pymodaq 4.1.5__py3-none-any.whl → 4.2.0__py3-none-any.whl

pymodaq/control_modules/daq_viewer_ui.py

@@ -19,7 +19,8 @@ from pymodaq.utils.gui_utils.widgets import PushButtonIcon, LabelWithFont, QLED
 from pymodaq.utils.gui_utils import Dock
 from pymodaq.utils.config import Config
 from pymodaq.control_modules.utils import DET_TYPES, DAQTypesEnum
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerFactory, ViewersEnum, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerFactory, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.enums import enum_checker
 
 

pymodaq/control_modules/move_utility_classes.py

@@ -1,5 +1,5 @@
 from time import perf_counter
-from typing import Union, List, Dict, TYPE_CHECKING
+from typing import Union, List, Dict, TYPE_CHECKING, Optional
 from numbers import Number
 
 from easydict import EasyDict as edict
@@ -122,6 +122,15 @@ params = [
               'value': config('network', 'tcp-server', 'ip')},
              {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'tcp-server', 'port')},
          ]},
+        {'title': 'LECO options:', 'name': 'leco', 'type': 'group', 'visible': True, 'expanded': False,
+         'children': [
+             {'title': 'Connect:', 'name': 'connect_leco_server', 'type': 'bool_push', 'label': 'Connect',
+              'value': False},
+             {'title': 'Connected?:', 'name': 'leco_connected', 'type': 'led', 'value': False},
+             {'title': 'Name', 'name': 'leco_name', 'type': 'str', 'value': "", 'default': ""},
+             {'title': 'Host:', 'name': 'host', 'type': 'str', 'value': config('network', "leco-server", "host"), "default": "localhost"},
+             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'leco-server', 'port')},
+         ]},
     ]},
     {'title': 'Actuator Settings:', 'name': 'move_settings', 'type': 'group'}
 ]
@@ -197,7 +206,8 @@ class DAQ_Move_base(QObject):
     data_actuator_type = DataActuatorType['float']
     data_shape = (1, )  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
 
-    def __init__(self, parent: 'DAQ_Move_Hardware' = None, params_state: dict = None):
+    def __init__(self, parent: Optional['DAQ_Move_Hardware'] = None,
+                 params_state: Optional[dict] = None):
         QObject.__init__(self)  # to make sure this is the parent class
         self.move_is_done = False
         self.parent = parent
@@ -280,7 +290,7 @@ class DAQ_Move_base(QObject):
     def ini_stage_init(self, old_controller=None, new_controller=None):
         """Manage the Master/Slave controller issue
 
-        First initialize the status dictionnary
+        First initialize the status dictionary
         Then check whether this stage is controlled by a multiaxe controller (to be defined for each plugin)
             if it is a multiaxes controller then:
             * if it is Master: init the controller here
@@ -438,7 +448,7 @@ class DAQ_Move_base(QObject):
     def commit_common_settings(self, param):
         pass
 
-    def move_done(self, position: DataActuator = None):  # the position argument is just there to match some signature of child classes
+    def move_done(self, position: Optional[DataActuator] = None):  # the position argument is just there to match some signature of child classes
         """
             | Emit a move done signal transmitting the float position to hardware.
             | The position argument is just there to match some signature of child classes.
@@ -494,7 +504,7 @@ class DAQ_Move_base(QObject):
             logger.debug(f'Check move_is_done: {self.move_is_done}')
             if self.move_is_done:
                 self.emit_status(ThreadCommand('Move has been stopped', ))
-                logger.info(f'Move has been stopped')
+                logger.info('Move has been stopped')
             self.current_value = self.get_actuator_value()
 
             self.emit_value(self._current_value)
@@ -503,7 +513,7 @@ class DAQ_Move_base(QObject):
             if perf_counter() - self.start_time >= self.settings['timeout']:
                 self.poll_timer.stop()
                 self.emit_status(ThreadCommand('raise_timeout', ))
-                logger.info(f'Timeout activated')
+                logger.info('Timeout activated')
         else:
             self.poll_timer.stop()
             logger.debug(f'Current value: {self._current_value}')
@@ -661,7 +671,7 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
 
     def ini_stage(self, controller=None):
         """
-            | Initialisation procedure of the detector updating the status dictionnary.
+            | Initialisation procedure of the detector updating the status dictionary.
             |
             | Init axes from image , here returns only None values (to tricky to di it with the server and not really necessary for images anyway)
 

pymodaq/control_modules/utils.py

@@ -4,18 +4,24 @@ Created the 03/10/2022
 
 @author: Sebastien Weber
 """
+from random import randint
+from typing import Optional, Type
+
 from easydict import EasyDict as edict
 
 from qtpy import QtCore
-from qtpy.QtCore import Signal, QObject, Qt
+from qtpy.QtCore import Signal, QObject, Qt, Slot, QThread
 from pymodaq.utils.gui_utils import CustomApp
 from pymodaq.utils.daq_utils import ThreadCommand, get_plugins, find_dict_in_list_from_key_val
 from pymodaq.utils.config import Config
-from pymodaq.utils.parameter import Parameter
+from pymodaq.utils.tcp_ip.tcp_server_client import TCPClient
+from pymodaq.utils.parameter import Parameter, ioxml
+from pymodaq.utils.managers.parameter_manager import ParameterManager
 from pymodaq.utils.enums import BaseEnum, enum_checker
-from pymodaq.utils.plotting.data_viewers.viewer import ViewersEnum
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.exceptions import DetectorError
 from pymodaq.utils import config as configmod
+from pymodaq.utils.leco.pymodaq_listener import ActorListener, LECOClientCommands, LECOCommands
 
 
 class DAQTypesEnum(BaseEnum):
@@ -116,7 +122,7 @@ class ControlModule(QObject):
         self._tcpclient_thread = None
         self._hardware_thread = None
         self.module_and_data_saver = None
-        self.plugin_config: configmod.Config = None
+        self.plugin_config: Optional[configmod.Config] = None
 
     def __repr__(self):
         return f'{self.__class__.__name__}: {self.title}'
@@ -253,7 +259,7 @@ class ControlModule(QObject):
         raise NotImplementedError
 
     def quit_fun(self):
-        """Programmatic entry to quit the controle module"""
+        """Programmatic entry to quit the control module"""
         raise NotImplementedError
 
     def init_hardware(self, do_init=True):
@@ -343,6 +349,148 @@ class ControlModule(QObject):
                         attr = value
 
 
+class ParameterControlModule(ParameterManager, ControlModule):
+    """Base class for a control module with parameters."""
+
+    _update_settings_signal = Signal(edict)
+
+    listener_class: Type[ActorListener] = ActorListener
+
+    def __init__(self, **kwargs):
+        QObject.__init__(self)
+        ParameterManager.__init__(self, action_list=('save', 'update'))
+        ControlModule.__init__(self)
+
+    def value_changed(self, param: Parameter) -> Optional[Parameter]:
+        """ParameterManager subclassed method. Process events from value changed by user in the UI Settings
+
+        Parameters
+        ----------
+        param: Parameter
+            a given parameter whose value has been changed by user
+        """
+        if param.name() == 'plugin_config':
+            self.show_config(self.plugin_config)
+
+        elif param.name() == 'connect_server':
+            if param.value():
+                self.connect_tcp_ip()
+            else:
+                self._command_tcpip.emit(ThreadCommand('quit', ))
+
+        elif param.name() == 'ip_address' or param.name == 'port':
+            self._command_tcpip.emit(
+                ThreadCommand('update_connection',
+                              dict(ipaddress=self.settings['main_settings', 'tcpip', 'ip_address'],
+                                   port=self.settings['main_settings', 'tcpip', 'port'])))
+
+        elif param.name() == 'connect_leco_server':
+            self.connect_leco(param.value())
+
+        elif param.name() == "name":
+            name = param.value()
+            try:
+                self._leco_client.name = name
+            except AttributeError:
+                pass
+
+        else:
+            # not handled
+            return param
+
+    def _update_settings(self, param: Parameter):
+        # I do not understand what it does
+        path = self.settings.childPath(param)
+        if path is not None:
+            if 'main_settings' not in path:
+                self._update_settings_signal.emit(edict(path=path, param=param, change='value'))
+                if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value():
+                    self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
+                if self.settings.child('main_settings', 'leco', 'leco_connected').value():
+                    self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
+
+    def connect_tcp_ip(self, params_state=None, client_type: str = "GRABBER") -> None:
+        """Init a TCPClient in a separated thread to communicate with a distant TCp/IP Server
+
+        Use the settings: ip_address and port to specify the connection
+
+        See Also
+        --------
+        TCPServer
+        """
+        if self.settings.child('main_settings', 'tcpip', 'connect_server').value():
+            self._tcpclient_thread = QThread()
+
+            tcpclient = TCPClient(self.settings.child('main_settings', 'tcpip', 'ip_address').value(),
+                                  self.settings.child('main_settings', 'tcpip', 'port').value(),
+                                  params_state=params_state,
+                                  client_type=client_type)
+            tcpclient.moveToThread(self._tcpclient_thread)
+            self._tcpclient_thread.tcpclient = tcpclient
+            tcpclient.cmd_signal.connect(self.process_tcpip_cmds)
+
+            self._command_tcpip[ThreadCommand].connect(tcpclient.queue_command)
+            self._tcpclient_thread.started.connect(tcpclient.init_connection)
+
+            self._tcpclient_thread.start()
+
+    def get_leco_name(self) -> str:
+        name = self.settings["main_settings", "leco", "leco_name"]
+        if name == '':
+            # take the module name as alternative
+            name = self.settings["main_settings", "module_name"]
+        if name == '':
+            # a name is required, invent one
+            name = f"viewer_{randint(0, 10000)}"
+            name = self.settings.child("main_settings", "leco", "leco_name").setValue(name)
+        return name
+
+    def connect_leco(self, connect: bool) -> None:
+        if connect:
+            name = self.get_leco_name()
+            try:
+                self._leco_client.name = name
+            except AttributeError:
+                self._leco_client = self.listener_class(name=name)
+                self._leco_client.cmd_signal.connect(self.process_tcpip_cmds)
+            self._command_tcpip[ThreadCommand].connect(self._leco_client.queue_command)
+            self._leco_client.start_listen()
+            # self._leco_client.cmd_signal.emit(ThreadCommand("set_info", attribute=["detector_settings", ""]))
+        else:
+            self._command_tcpip.emit(ThreadCommand(LECOCommands.QUIT, ))
+            try:
+                self._command_tcpip[ThreadCommand].disconnect(self._leco_client.queue_command)
+            except TypeError:
+                pass  # already disconnected
+
+    @Slot(ThreadCommand)
+    def process_tcpip_cmds(self, status: ThreadCommand) -> Optional[ThreadCommand]:
+        if status.command == 'connected':
+            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(True)
+
+        elif status.command == 'disconnected':
+            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(False)
+
+        elif status.command == LECOClientCommands.LECO_CONNECTED:
+            self.settings.child('main_settings', 'leco', 'leco_connected').setValue(True)
+
+        elif status.command == LECOClientCommands.LECO_DISCONNECTED:
+            self.settings.child('main_settings', 'leco', 'leco_connected').setValue(False)
+
+        elif status.command == 'Update_Status':
+            self.thread_status(status)
+
+        elif status.command == 'set_info':
+            param_dict = ioxml.XML_string_to_parameter(status.attribute[1])[0]
+            param_tmp = Parameter.create(**param_dict)
+            param = self.settings.child('move_settings', *status.attribute[0][1:])
+
+            param.restoreState(param_tmp.saveState())
+        else:
+            # not handled
+            return status
+
+
 class ControlModuleUI(CustomApp):
     """ Base Class for ControlModules UIs
 

pymodaq/control_modules/viewer_utility_classes.py

@@ -57,6 +57,15 @@ params = [
              'value': config('network', 'tcp-server', 'ip')},
             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'tcp-server', 'port')},
         ]},
+        {'title': 'LECO options:', 'name': 'leco', 'type': 'group', 'visible': True, 'expanded': False,
+         'children': [
+             {'title': 'Connect:', 'name': 'connect_leco_server', 'type': 'bool_push', 'label': 'Connect',
+              'value': False},
+             {'title': 'Connected?:', 'name': 'leco_connected', 'type': 'led', 'value': False},
+             {'title': 'Name', 'name': 'leco_name', 'type': 'str', 'value': "", 'default': ""},
+             {'title': 'Host:', 'name': 'host', 'type': 'str', 'value': config('network', "leco-server", "host"), "default": "localhost"},
+             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'leco-server', 'port')},
+         ]},
         {'title': 'Overshoot options:', 'name': 'overshoot', 'type': 'group', 'visible': True, 'expanded': False,
          'children': [
              {'title': 'Overshoot:', 'name': 'stop_overshoot', 'type': 'bool', 'value': False},
@@ -129,7 +138,7 @@ class DAQ_Viewer_base(QObject):
         *params*                list
         *settings*              instance of pyqtgraph Parameter
         *parent*                ???
-        *status*                dictionnary
+        *status*                dictionary
         ===================== ===================================
 
         See Also
@@ -182,22 +191,25 @@ class DAQ_Viewer_base(QObject):
 
         self.ini_attributes()
 
-        self.data_grabed_signal.connect(self._emit_dte)
-        self.data_grabed_signal_temp.connect(self._emit_dte_temp)
+        try:
+            self.data_grabed_signal.connect(self._emit_dte)
+            self.data_grabed_signal_temp.connect(self._emit_dte_temp)
+        except Exception as exc:
+            print(f"Error with old message signal stuff: {exc}")
 
     def _emit_dte(self, dte: Union[DataToExport, list]):
         if isinstance(dte, list):
-            deprecation_msg(f'Data emitted from the instrument plugins should be a DataToExport instance'
-                            f'See: http://pymodaq.cnrs.fr/en/latest/developer_folder/'
-                            f'instrument_plugins.html#emission-of-data')
+            deprecation_msg('Data emitted from the instrument plugins should be a DataToExport instance'
+                            'See: http://pymodaq.cnrs.fr/en/latest/developer_folder/'
+                            'instrument_plugins.html#emission-of-data')
             dte = DataToExport('temp', dte)
         self.dte_signal.emit(dte)
 
     def _emit_dte_temp(self, dte: Union[DataToExport, list]):
         if isinstance(dte, list):
-            deprecation_msg(f'Data emitted from the instrument plugins should be a DataToExport instance'
-                            f'See: http://pymodaq.cnrs.fr/en/latest/developer_folder/'
-                            f'instrument_plugins.html#emission-of-data')
+            deprecation_msg('Data emitted from the instrument plugins should be a DataToExport instance'
+                            'See: http://pymodaq.cnrs.fr/en/latest/developer_folder/'
+                            'instrument_plugins.html#emission-of-data')
             dte = DataToExport('temp', dte)
         self.dte_signal_temp.emit(dte)
 
@@ -210,7 +222,7 @@ class DAQ_Viewer_base(QObject):
     def ini_detector_init(self, old_controller=None, new_controller=None):
         """Manage the Master/Slave controller issue
 
-        First initialize the status dictionnary
+        First initialize the status dictionary
         Then check whether this stage is controlled by a multiaxe controller (to be defined for each plugin)
             if it is a multiaxes controller then:
             * if it is Master: init the controller here
@@ -241,28 +253,28 @@ class DAQ_Viewer_base(QObject):
         Mandatory
         To be reimplemented in subclass
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     def close(self):
         """
         Mandatory
         To be reimplemented in subclass
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     def grab_data(self, Naverage=1, **kwargs):
         """
         Mandatory
         To be reimplemented in subclass
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     def stop(self):
         """
         Mandatory
         To be reimplemented in subclass
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     def commit_settings(self, param):
         """
@@ -296,7 +308,7 @@ class DAQ_Viewer_base(QObject):
             print(status)
 
     def update_scanner(self, scan_parameters):
-        #todo check this because ScanParameters has been removed
+        # todo check this because ScanParameters has been removed
         self.scan_parameters = scan_parameters
 
     @Slot(edict)
@@ -307,7 +319,7 @@ class DAQ_Viewer_base(QObject):
 
             ========================== ============= =====================================================
             **Parameters**              **Type**      **Description**
-            *settings_parameter_dict*   dictionnnary  a dictionnary listing path and associated parameter
+            *settings_parameter_dict*   dictionnnary  a dictionary listing path and associated parameter
             ========================== ============= =====================================================
 
             See Also
@@ -378,7 +390,6 @@ class DAQ_Viewer_base(QObject):
             pass
 
 
-
 class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
     """
         ================= ==============================
@@ -413,7 +424,7 @@ class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
         grabber_type: (str) either '0D', '1D' or '2D'
         """
         self.client_type = "GRABBER"
-        DAQ_Viewer_base.__init__(self, parent, params_state)  # initialize base class with commom attribute and methods
+        DAQ_Viewer_base.__init__(self, parent, params_state)  # initialize base class with common attribute and methods
         TCPServer.__init__(self, self.client_type)
 
         self.x_axis = None
@@ -469,7 +480,7 @@ class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
 
     def data_ready(self, data: DataToExport):
         """
-            Send the grabed data signal.
+            Send the grabbed data signal.
         """
         self.dte_signal.emit(data)
 
@@ -505,7 +516,7 @@ class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
 
     def ini_detector(self, controller=None):
         """
-            | Initialisation procedure of the detector updating the status dictionnary.
+            | Initialisation procedure of the detector updating the status dictionary.
             |
             | Init axes from image , here returns only None values (to tricky to di it with the server and not really
              necessary for images anyway)

pymodaq/dashboard.py

@@ -16,6 +16,7 @@ import numpy as np
 from pymodaq.utils.logger import set_logger, get_module_name
 from pymodaq.utils.gui_utils import DockArea, Dock, select_file
 import pymodaq.utils.gui_utils.layout as layout_mod
+from pymodaq.utils.gui_utils.utils import start_qapplication
 from pymodaq.utils.messenger import messagebox
 from pymodaq.utils.parameter import utils as putils
 from pymodaq.utils import daq_utils as utils
@@ -28,7 +29,7 @@ from pymodaq.utils.managers.roi_manager import ROISaver
 from pymodaq.utils.exceptions import DetectorError, ActuatorError, PIDError, MasterSlaveError
 from pymodaq.utils import config as configmod
 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
 
@@ -214,6 +215,19 @@ class DashBoard(QObject):
 
         return qtconsole
 
+    def load_bayesian(self, win=None):
+        if win is None:
+            self.bayesian_window = QtWidgets.QMainWindow()
+        else:
+            self.bayesian_window = win
+        dockarea = DockArea()
+        self.bayesian_window.setCentralWidget(dockarea)
+        self.bayesian_window.setWindowTitle('Bayesian Optimiser')
+        self.bayesian_module = extmod.BayesianOptimisation(dockarea=dockarea, dashboard=self)
+        self.extensions['bayesian'] = self.bayesian_module
+        self.bayesian_window.show()
+        return self.bayesian_module
+
     def load_extension_from_name(self, name: str) -> dict:
         self.load_extensions_module(find_dict_in_list_from_key_val(extensions, 'name', name))
 
@@ -262,6 +276,8 @@ class DashBoard(QObject):
         restart_action.triggered.connect(self.restart_fun)
 
         self.settings_menu = menubar.addMenu('Settings')
+        action_leco = self.settings_menu.addAction('Run Leco Coordinator')
+        action_leco.triggered.connect(start_coordinator)
         docked_menu = self.settings_menu.addMenu('Docked windows')
         action_load = docked_menu.addAction('Load Layout')
         action_save = docked_menu.addAction('Save Layout')
@@ -348,6 +364,8 @@ class DashBoard(QObject):
         action_pid.triggered.connect(lambda: self.load_pid_module())
         action_console = self.actions_menu.addAction('IPython Console')
         action_console.triggered.connect(lambda: self.load_console())
+        action_bayesian = self.actions_menu.addAction('Bayesian Optimisation')
+        action_bayesian.triggered.connect(lambda: self.load_bayesian())
 
         extensions_actions = []
         for ext in extensions:
@@ -501,6 +519,9 @@ class DashBoard(QObject):
         try:
             self.remote_timer.stop()
 
+            for ext in self.extensions:
+                if hasattr(self.extensions[ext], 'quit_fun'):
+                    self.extensions[ext].quit_fun()
             for mov in self.actuators_modules:
                 mov.init_signal.disconnect(self.update_init_tree)
             for det in self.detector_modules:
@@ -1395,10 +1416,7 @@ class DashBoard(QObject):
 
 def main(init_qt=True):
     if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-        if config('style', 'darkstyle'):
-            import qdarkstyle
-            app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
+        app = start_qapplication()
 
     win = QtWidgets.QMainWindow()
     area = DockArea()

pymodaq/examples/tcp_client.py

@@ -0,0 +1,97 @@
+"""
+Minimal example of a TCP client connecting to a TCP server instrument class plugin (type 0D) and
+sending to it 0D data in a row representing a sinus.
+
+To execute all this:
+
+* start a Daq_Viewer from the console, select DAQ0D and TCP_Server, set the IP to localhost, then init
+* execute this script
+
+You should see the TCP server printing the sinus in its 0D data viewer
+
+"""
+
+
+import numpy as np
+
+from pymodaq.utils.tcp_ip.tcp_server_client import TCPClientTemplate
+from pymodaq.utils.data import DataToExport, DataRaw
+
+
+class TCPClient(TCPClientTemplate):
+    def __init__(self):
+        super().__init__(ipaddress="localhost", port=6341, client_type="GRABBER")
+
+    def post_init(self, extra_commands=[]):
+        self.socket.check_sended_with_serializer(self.client_type)
+
+    def send_data(self, data: DataToExport):
+        # first send 'Done' and then send the length of the list
+        if not isinstance(data, DataToExport):
+            raise TypeError(f'should send a DataToExport object')
+        if self.socket is not None:
+            self.socket.check_sended_with_serializer('Done')
+            self.socket.check_sended_with_serializer(data)
+
+    def ready_to_read(self):
+        message = self._deserializer.string_deserialization()
+        self.get_data(message)
+
+    def get_data(self, message: str):
+        """
+
+        Parameters
+        ----------
+        message
+
+        Returns
+        -------
+
+        """
+        if self.socket is not None:
+
+            if message == 'set_info':
+                path = self._deserializer.list_deserialization()
+                param_xml = self._deserializer.string_deserialization()
+                print(param_xml)
+
+            elif message == 'move_abs' or message == 'move_rel':
+                position = self._deserializer.dwa_deserialization()
+                print(f'Position is {position}')
+
+            else:
+                print(message)
+
+    def data_ready(self, data: DataToExport):
+        self.send_data(data)
+
+    def ready_to_write(self):
+        pass
+
+    def ready_with_error(self):
+        self.connected = False
+
+    def process_error_in_polling(self, e: Exception):
+        print(e)
+
+
+
+if __name__ == '__main__':
+    from threading import Thread
+    from time import sleep
+
+    tcpclient = TCPClient()
+    t = Thread(target=tcpclient.init_connection)
+
+    t.start()
+    sleep(1)
+    sinus = np.sin(np.linspace(0, 2 * np.pi, 10))
+
+    for ind in range(10):
+        dwa = DataRaw('mydata', data=[np.array([sinus[ind]])], plot=True)
+        tcpclient.data_ready(dwa.as_dte())
+
+    tcpclient.close()
+
+
+

pymodaq/extensions/__init__.py

@@ -13,4 +13,8 @@ from .daq_logger import DAQ_Logger
 from .pid.pid_controller import DAQ_PID
 from .h5browser import H5Browser
 
+from .bayesian.bayesian_optimisation import BayesianOptimisation
+from .bayesian.utils import BayesianModelDefault, BayesianModelGeneric
+
+
 

pymodaq/extensions/bayesian/__init__.py

@@ -0,0 +1,2 @@
+from . import bayesian_optimisation
+from . import utils