pymodaq 5.1.6__py3-none-any.whl

pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.aliases

@@ -0,0 +1,3 @@
+[My Computer]
+My Computer = "169.254.172.128"
+

pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.lvlps

@@ -0,0 +1,3 @@
+[ProjectWindow_Data]
+ProjectExplorer.ClassicPosition[String] = "566,488,1252,1090"
+

pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.lvproj

@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<Project Type="Project" LVVersion="16008000">
+	<Item Name="My Computer" Type="My Computer">
+		<Property Name="server.app.propertiesEnabled" Type="Bool">true</Property>
+		<Property Name="server.control.propertiesEnabled" Type="Bool">true</Property>
+		<Property Name="server.tcp.enabled" Type="Bool">false</Property>
+		<Property Name="server.tcp.port" Type="Int">0</Property>
+		<Property Name="server.tcp.serviceName" Type="Str">My Computer/VI Server</Property>
+		<Property Name="server.tcp.serviceName.default" Type="Str">My Computer/VI Server</Property>
+		<Property Name="server.vi.callsEnabled" Type="Bool">true</Property>
+		<Property Name="server.vi.propertiesEnabled" Type="Bool">true</Property>
+		<Property Name="specify.custom.address" Type="Bool">false</Property>
+		<Item Name="controls" Type="Folder">
+			<Item Name="client_state.ctl" Type="VI" URL="../client_state.ctl"/>
+			<Item Name="cmd_types.ctl" Type="VI" URL="../cmd_types.ctl"/>
+		</Item>
+		<Item Name="subvis" Type="Folder">
+			<Item Name="DAQ_TCP_read_cmd.vi" Type="VI" URL="../DAQ_TCP_read_cmd.vi"/>
+			<Item Name="DAQ_TCP_read_float.vi" Type="VI" URL="../DAQ_TCP_read_float.vi"/>
+			<Item Name="DAQ_TCP_read_int.vi" Type="VI" URL="../DAQ_TCP_read_int.vi"/>
+			<Item Name="DAQ_TCP_send_data.vi" Type="VI" URL="../DAQ_TCP_send_data.vi"/>
+			<Item Name="DAQ_TCP_send_int.vi" Type="VI" URL="../DAQ_TCP_send_int.vi"/>
+			<Item Name="DAQ_TCP_send_scalar.vi" Type="VI" URL="../DAQ_TCP_send_scalar.vi"/>
+			<Item Name="DAQ_TCP_send_string.vi" Type="VI" URL="../DAQ_TCP_send_string.vi"/>
+			<Item Name="DAQ_TCP_Server_1Dgaussian.vi" Type="VI" URL="../DAQ_TCP_Server_1Dgaussian.vi"/>
+			<Item Name="DAQ_TCP_Server_2Dgaussian.vi" Type="VI" URL="../DAQ_TCP_Server_2Dgaussian.vi"/>
+		</Item>
+		<Item Name="DAQ_TCP_Client.vi" Type="VI" URL="../DAQ_TCP_Client.vi"/>
+		<Item Name="Dependencies" Type="Dependencies"/>
+		<Item Name="Build Specifications" Type="Build"/>
+	</Item>
+</Project>

pymodaq/examples/function_plotter.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 27/06/2022
+
+@author: Sebastien Weber
+"""
+
+import numpy as np
+from qtpy import QtWidgets
+from qtpy.QtCore import Slot, QDate, QThread, QTimer
+
+from pymodaq.utils import data as data_mod
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq_gui.utils.custom_app import CustomApp
+from pymodaq_gui.utils.dock import DockArea, Dock
+from pymodaq_data.data import DataRaw, Axis
+from pymodaq_utils.config import Config
+
+from pymodaq_gui.plotting.data_viewers.viewer1D import Viewer1D
+
+
+config = Config()
+logger = set_logger(get_module_name(__file__))
+
+
+class FunctionPlotter(CustomApp):
+
+    # list of dicts enabling the settings tree on the user interface
+    params = [
+            {'title': 'Save base path:', 'name': 'base_path', 'type': 'browsepath',
+             'value': config('data_saving', 'h5file', 'save_path')},
+            {'title': 'File name:', 'name': 'target_filename', 'type': 'str', 'value': "", 'readonly': True},
+            {'title': 'Date:', 'name': 'date', 'type': 'date', 'value': QDate.currentDate()},
+
+            {'title': 'Functions:', 'name': 'functions', 'type': 'list',
+             'limits': ['exp(-(x/5)**2)', 'sin(x)', 'arctan(x)']},
+            {'title': 'Function:', 'name': 'function', 'type': 'str', 'value': 'sinc(x)'},
+            {'title': 'Add function:', 'label': 'Add!', 'name': 'add_function', 'type': 'bool_push', 'value': False},
+            {'title': 'Plot refresh (ms):', 'name': 'plot_refresh', 'type': 'int', 'value': 2000},
+            {'title': 'Xaxis:', 'name': 'xaxis', 'type': 'group', 'children': [
+                {'title': 'Npts:', 'name': 'npoints', 'type': 'int', 'value': 200},
+                {'title': 'Xstart:', 'name': 'xstart', 'type': 'float', 'value': -10},
+                {'title': 'Xstop:', 'name': 'xstop', 'type': 'int', 'value': 10},
+            ]}
+    ]
+
+    def __init__(self, dockarea):
+        super().__init__(dockarea)
+
+        # init the object parameters
+        self.raw_data = []
+        self.setup_ui()  # will trigger:
+        #                  self.setup_docks()
+        #                  self.setup_actions()  # see ActionManager MixIn class
+        #                  self.setup_menu()
+        #                  self.connect_things()
+        self.timer = QTimer()
+        self.timer.setInterval(self.settings['plot_refresh'])
+        self.timer.timeout.connect(self.plot_timer)
+
+        self.ind_plot = 0
+
+    def setup_docks(self):
+        """
+        subclass method from CustomApp
+        """
+        logger.debug('setting docks')
+        self.dock_settings = Dock('Settings', size=(350, 350))
+        self.dockarea.addDock(self.dock_settings, 'left')
+        self.dock_settings.addWidget(self.settings_tree, 10)
+        # settings_tree is an inherited property of the ParameterManager base class
+
+        # create a dock containing a viewer object
+        dock_viewer = Dock('Viewer dock', size=(350, 350))
+        self.dockarea.addDock(dock_viewer, 'right', self.dock_settings)  # add this dock to the right of the settings one
+        viewer_widget = QtWidgets.QWidget()
+        self.viewer = Viewer1D(viewer_widget)
+        dock_viewer.addWidget(viewer_widget)
+
+        logger.debug('docks are set')
+
+    def setup_actions(self):
+        """
+        subclass method from ActionManager
+        """
+        logger.debug('setting actions')
+        self.add_action('quit', 'Quit', 'close2', "Quit program", toolbar=self.toolbar)
+        # toolbar is an inherited property of the ActionManager base class
+
+        self.add_action('show', 'Show/hide', 'read2', "Show Hide Viewer", checkable=True, toolbar=self.toolbar)
+        self.add_action('plot', 'Plot', 'snap', "Plot", checkable=False, toolbar=self.toolbar)
+        self.add_action('plot_seq', 'Plot Sequence', 'camera', "Plot functions", checkable=True, toolbar=self.toolbar)
+        self.add_action('save', 'Save', 'SaveAs', "Save current function", checkable=False, toolbar=self.toolbar)
+        logger.debug('actions set')
+
+    def connect_things(self):
+        self.connect_action('quit', self.quit)
+        self.connect_action('plot', self.plot)
+
+        self.connect_action('plot_seq', self.plot_all)
+
+    def quit(self):
+        self.mainwindow.close()
+
+    def plot(self):
+        function_str = self.settings['functions']
+        x = np.linspace(self.settings['xaxis', 'xstart'], self.settings['xaxis', 'xstop'],
+                        self.settings['xaxis', 'npoints'])
+
+        function_vals = eval(f'np.{function_str}')
+
+        self.viewer.show_data(DataRaw(name=function_str,
+                                      data=[function_vals],
+                                      labels=[function_str],
+                                      axes=[
+                                          data_mod.Axis(
+                                              data=x, label='An axis', units='arb. units')],
+                                      )
+                              )
+
+    def value_changed(self, param):
+        if param.name() == 'add_function':
+            function_list = [self.settings['function']]
+            old_functions = self.functions
+            function_list.extend(old_functions)
+            function_list = list(np.unique(function_list))
+            self.settings.child('functions').setLimits(function_list)
+            param.setValue(False)
+
+    @property
+    def functions(self):
+        return self.settings.child('functions').opts['limits']
+
+    def plot_timer(self):
+        self.settings.child('functions').setValue(self.functions[self.ind_plot % len(self.functions)])
+        self.plot()
+        self.ind_plot += 1
+
+    def plot_all(self):
+        if self.is_action_checked('plot_seq'):
+            self.timer.start()
+        else:
+            self.timer.stop()
+
+
+def main():
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    mainwindow = QtWidgets.QMainWindow()
+    dockarea = DockArea()
+    mainwindow.setCentralWidget(dockarea)
+
+    prog = FunctionPlotter(dockarea)
+
+    mainwindow.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

pymodaq/examples/nonlinearscanner.py

@@ -0,0 +1,126 @@
+
+import numpy as np
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.gui_utils.custom_app import CustomApp
+from pymodaq.utils.gui_utils.dock import DockArea, Dock
+from pymodaq.utils.config import Config, get_set_preset_path
+from qtpy import QtWidgets
+from qtpy.QtCore import Signal, QLocale
+
+from pymodaq.utils import gui_utils as gutils
+from pymodaq.utils import daq_utils as utils
+
+
+config = Config()
+logger = set_logger(get_module_name(__file__))
+
+
+class NonLinearScanner(CustomApp):
+
+    positions_signal = Signal(np.ndarray)
+
+    # list of dicts enabling the settings tree on the user interface
+    params = [
+        {'title': 'Init Position:', 'name': 'ini_pos', 'type': 'float', 'value': 0, },
+        {'title': 'Saturation pos:', 'name': 'satu_pos', 'type': 'float', 'value': 5, },
+        {'title': 'Start scan:', 'name': 'start_scan', 'type': 'float', 'value': 4, },
+        {'title': 'Stop Scan:', 'name': 'stop_scan', 'type': 'float', 'value': 3, },
+        {'title': 'Step Scan:', 'name': 'step_scan', 'type': 'float', 'value': -0.05, },
+        {'title': 'Apply', 'name': 'apply', 'type': 'action',},
+
+    ]
+
+    def __init__(self, dockarea):
+        
+        super().__init__(dockarea)
+        self.setup_ui()
+
+    def setup_actions(self):
+        '''
+        subclass method from ActionManager
+        '''
+        logger.debug('setting actions')
+
+        logger.debug('actions set')
+
+    def setup_docks(self):
+        '''
+        subclass method from CustomApp
+        '''
+        logger.debug('setting docks')
+        self.dock_settings = Dock('Settings', size=(350, 350))
+        self.dockarea.addDock(self.dock_settings, 'left')
+        self.dock_settings.addWidget(self.settings_tree, 10)
+        logger.debug('docks are set')
+
+    def connect_things(self):
+        '''
+        subclass method from CustomApp
+        '''
+        logger.debug('connecting things')
+        self.settings.child('apply').sigActivated.connect(self.emit_positions)
+        logger.debug('connecting done')
+
+    def setup_menu(self):
+        '''
+        subclass method from CustomApp
+        '''
+        logger.debug('settings menu')
+
+
+        logger.debug('menu set')
+
+    def value_changed(self, param):
+        logger.debug(f'calling value_changed with param {param.name()}')
+
+        logger.debug(f'Value change applied')
+
+    def update_positions(self):
+        xini = self.settings.child('ini_pos').value()
+        sat = self.settings.child('satu_pos').value()
+        start = self.settings.child('start_scan').value()
+        stop = self.settings.child('stop_scan').value()
+        step = self.settings.child('step_scan').value()
+
+        return np.concatenate((np.array([xini, sat]), utils.linspace_step(start, stop, step), np.array([xini])))
+
+    def emit_positions(self):
+        self.positions_signal.emit(np.transpose(np.array([self.update_positions()])))
+
+
+def main():
+    import sys
+    from pathlib import Path
+    app = QtWidgets.QApplication(sys.argv)
+
+    from pymodaq.dashboard import DashBoard
+
+    win = QtWidgets.QMainWindow()
+    area = DockArea()
+    win.setCentralWidget(area)
+    win.resize(1000, 500)
+    win.setWindowTitle('PyMoDAQ Dashboard')
+
+    dash = DashBoard(area)
+    file = Path(get_set_preset_path()).joinpath(f"{config('presets', 'default_preset_for_scan')}.xml")
+    if file.exists():
+        dash.set_preset_mode(file)
+        dash.load_scan_module()
+
+
+    mainwindow = QtWidgets.QMainWindow()
+    dockarea = DockArea()
+    mainwindow.setCentralWidget(dockarea)
+
+    prog = NonLinearScanner(dockarea)
+
+    QtWidgets.QApplication.processEvents()
+    prog.positions_signal.connect(dash.scan_module.scanner.update_tabular_positions)
+
+    mainwindow.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

pymodaq/examples/qt_less_standalone_module.py

@@ -0,0 +1,165 @@
+"""
+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 cast, List, Optional
+
+from pyleco.utils.listener import Listener
+
+
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.factory import SerializableFactory
+
+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 = []
+        # register DataWithAxes for deserialization
+        cls = DataWithAxes
+        SerializableFactory().register_from_type(cls, cls.serialize, cls.deserialize)
+
+    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)
+        # binary methods can accept additionally binary payload, like serialized pymodaq objects.
+        self.listener.register_binary_rpc_method(self.move_abs, accept_binary_input=True)
+        self.listener.register_binary_rpc_method(self.move_rel, accept_binary_input=True)
+        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()
+
+    @staticmethod
+    def extract_pymodaq_object(
+        value: Optional[float], additional_payload: Optional[List[bytes]]
+    ):
+        if value is None and additional_payload:
+            res = cast(DataWithAxes, SerializableFactory().get_apply_deserializer(additional_payload[0]))
+        else:
+            res = value
+        return res
+
+    # methods 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: Optional[float],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move to an absolute position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        print("move_abs", pos)
+        self._fake_position = float(pos)
+
+    def move_rel(
+        self,
+        position: Optional[float],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move by a relative position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        print("move_rel", pos)
+        self._fake_position += float(pos)
+
+    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/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_data.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

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 25/10/2022
+
+@author: Sebastien Weber
+"""
+from .utils import get_extensions
+from .pid.utils import get_models
+
+from .console import QtConsole
+from .daq_scan import DAQScan
+from .daq_logger.daq_logger import DAQ_Logger
+from .pid.pid_controller import DAQ_PID
+from .h5browser import H5Browser  #backcompat but should be loaded from pymodaq_gui!
+
+from .bayesian.bayesian_optimization import BayesianOptimization
+from .bayesian.utils import OptimizerModelDefault
+
+from .adaptive.adaptive_optimization import AdaptiveOptimisation
+
+from .data_mixer.data_mixer import DataMixer
+
+
+
+

pymodaq/extensions/adaptive/__init__.py

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