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

pymodaq/utils/tcp_ip/serializer.py

@@ -8,10 +8,13 @@ from base64 import b64encode, b64decode
 import numbers
 from typing import Tuple, List, Union, TYPE_CHECKING, Iterable
 
-
 import numpy as np
-from pymodaq.utils import data as data_mod
-from pymodaq.utils.data import DataWithAxes, DataToExport, Axis, DwaType
+from pymodaq_data import data as data_mod
+from pymodaq_data.data import DataWithAxes, DataToExport, Axis, DwaType
+
+from pymodaq_gui.parameter import Parameter, utils as putils, ioxml
+
+import pymodaq.utils.data as data_mod_pymodaq
 
 if TYPE_CHECKING:
     from pymodaq.utils.tcp_ip.mysocket import Socket
@@ -270,7 +273,8 @@ class Serializer:
         return bytes_string
 
     def object_type_serialization(self, obj: Union[Axis, DataToExport, DataWithAxes]) -> bytes:
-        """ Convert an object type into a bytes message as a string together with the info to convert it back
+        """ Convert an object type into a bytes message as a string together with the info to
+        convert it back
 
         Applies to Data object from the pymodaq.utils.data module
         """
@@ -361,6 +365,10 @@ class Serializer:
             bytes_string += self.string_serialization('array')
             bytes_string += self.ndarray_serialization(obj)
 
+        elif isinstance(obj, bytes):
+            bytes_string += self.string_serialization('bytes')
+            bytes_string += self.bytes_serialization(obj)
+
         elif isinstance(obj, str):
             bytes_string += self.string_serialization('string')
             bytes_string += self.string_serialization(obj)
@@ -377,6 +385,17 @@ class Serializer:
             bytes_string += self.string_serialization('list')
             bytes_string += self.list_serialization(obj)
 
+        elif isinstance(obj, putils.ParameterWithPath):
+            path = obj.path
+            param_as_xml = ioxml.parameter_to_xml_string(obj.parameter)
+            bytes_string += self.string_serialization('parameter')
+            bytes_string += self.list_serialization(path)
+            bytes_string += self.string_serialization(param_as_xml)
+
+        elif isinstance(obj, DataToExport):
+            bytes_string += self.string_serialization('dte')
+            bytes_string += self.dte_serialization(obj)
+
         else:
             raise TypeError(
                 f'the element {obj} type cannot be serialized into bytes, only numpy arrays'
@@ -550,6 +569,11 @@ class DeSerializer:
         int_obj = self.bytes_to_int(self._bytes_string.get_first_nbytes(4))
         return int_obj
 
+    def bytes_deserialization(self) -> bytes:
+        bstring_len = self._int_deserialization()
+        bstr = self._bytes_string.get_first_nbytes(bstring_len)
+        return bstr
+
     def string_deserialization(self) -> str:
         """Convert bytes into a str object
 
@@ -617,23 +641,36 @@ class DeSerializer:
         ndarray = np.atleast_1d(ndarray)  # remove singleton dimensions
         return ndarray
 
-    def object_deserialization(self):
+    def type_and_object_deserialization(self):
+        """ Deserialize specific objects from their binary representation (inverse of `Serializer.type_and_object_serialization`).
+
+        See Also
+        --------
+        Serializer.dwa_serialization, Serializer.dte_serialization
+
+        """
         obj_type = self.string_deserialization()
         elt = None
         if obj_type == 'scalar':
             elt = self.scalar_deserialization()
         elif obj_type == 'string':
             elt = self.string_deserialization()
+        elif obj_type == 'bytes':
+            elt = self.bytes_deserialization()
         elif obj_type == 'array':
             elt = self.ndarray_deserialization()
         elif obj_type == 'dwa':
             elt = self.dwa_deserialization()
+        elif obj_type == 'dte':
+            elt = self.dte_deserialization()
         elif obj_type == 'axis':
             elt = self.axis_deserialization()
         elif obj_type == 'bool':
             elt = self.boolean_deserialization()
         elif obj_type == 'list':
             elt = self.list_deserialization()
+        elif obj_type == 'parameter':
+            elt = self.parameter_deserialization()
         else:
             print(f'invalid object type {obj_type}')
         return elt
@@ -651,9 +688,16 @@ class DeSerializer:
         list_len = self._int_deserialization()
 
         for ind in range(list_len):
-            list_obj.append(self.object_deserialization())
+            list_obj.append(self.type_and_object_deserialization())
         return list_obj
 
+    def parameter_deserialization(self) -> putils.ParameterWithPath:
+        path = self.list_deserialization()
+        param_as_xml = self.string_deserialization()
+        param_dict = ioxml.XML_string_to_parameter(param_as_xml)
+        param_obj = Parameter(**param_dict[0])
+        return putils.ParameterWithPath(param_obj, path)
+
     def axis_deserialization(self) -> Axis:
         """Convert bytes into an Axis object
 
@@ -690,22 +734,26 @@ class DeSerializer:
         if class_name not in DwaType.names():
             raise TypeError(f'Attempting to deserialize a DataWithAxes flavor but got the bytes for a {class_name}')
         timestamp = self.scalar_deserialization()
-        dwa = getattr(data_mod, class_name)(self.string_deserialization(),
-                                            source=self.string_deserialization(),
-                                            dim=self.string_deserialization(),
-                                            distribution=self.string_deserialization(),
-                                            data=self.list_deserialization(),
-                                            labels=self.list_deserialization(),
-                                            origin=self.string_deserialization(),
-                                            nav_indexes=tuple(self.list_deserialization()),
-                                            axes=self.list_deserialization(),
+        try:
+            dwa_class = getattr(data_mod, class_name)
+        except AttributeError:  # in case it is a particular data object defined only in pymodaq
+            dwa_class = getattr(data_mod_pymodaq, class_name)
+        dwa = dwa_class(self.string_deserialization(),
+                        source=self.string_deserialization(),
+                        dim=self.string_deserialization(),
+                        distribution=self.string_deserialization(),
+                        data=self.list_deserialization(),
+                        labels=self.list_deserialization(),
+                        origin=self.string_deserialization(),
+                        nav_indexes=tuple(self.list_deserialization()),
+                        axes=self.list_deserialization(),
                                             )
         errors = self.list_deserialization()
         if len(errors) != 0:
             dwa.errors = errors
         dwa.extra_attributes = self.list_deserialization()
         for attribute in dwa.extra_attributes:
-            setattr(dwa, attribute, self.object_deserialization())
+            setattr(dwa, attribute, self.type_and_object_deserialization())
 
         dwa.timestamp = timestamp
         return dwa

pymodaq/utils/tcp_ip/tcp_server_client.py

@@ -14,17 +14,19 @@ import numpy as np
 from qtpy.QtCore import QObject, Signal, Slot, QThread
 from qtpy import QtWidgets
 
-from pymodaq.utils.parameter import utils as putils
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.daq_utils import getLineInfo, ThreadCommand
+
+from pymodaq_utils.utils import getLineInfo, ThreadCommand
+from pymodaq_utils import math_utils as mutils
+from pymodaq_utils.config import Config
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.parameter import Parameter
+from pymodaq_data.data import DataToExport
+
 from pymodaq.utils.data import DataFromPlugins, DataActuator
-from pymodaq.utils import math_utils as mutils
-from pymodaq.utils.config import Config
-from pymodaq.utils.parameter import Parameter
-from pymodaq.utils.data import DataToExport
 from pymodaq.utils.tcp_ip.mysocket import Socket
 from pymodaq.utils.tcp_ip.serializer import Serializer, DeSerializer
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_gui.managers.parameter_manager import ParameterManager
 
 config = Config()
 

{pymodaq-4.2.4.dist-info → pymodaq-5.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.2.4
+Version: 5.0.0
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -34,7 +34,6 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -43,7 +42,7 @@ Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Requires-Dist: bayesian-optimization
 Requires-Dist: easydict
 Requires-Dist: importlib-metadata; python_version < '3.8'
@@ -52,8 +51,11 @@ Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: pyleco; python_version >= '3.8'
+Requires-Dist: pymodaq-data
+Requires-Dist: pymodaq-gui
 Requires-Dist: pymodaq-plugin-manager>=0.0.17
 Requires-Dist: pymodaq-plugins-mock
+Requires-Dist: pymodaq-utils
 Requires-Dist: pyqtgraph>=0.12
 Requires-Dist: python-dateutil
 Requires-Dist: qdarkstyle

pymodaq-5.0.0.dist-info/RECORD

@@ -0,0 +1,123 @@
+pymodaq/__init__.py,sha256=Tfgreu3lNKud62iXpSWOUBFBDZIw-_w7bt4yDDgveT0,4286
+pymodaq/dashboard.py,sha256=ZiVfhjXXIkap8ALHW-3yd9kSY_cUBSD7NhPc4AJcwWU,64853
+pymodaq/icon.ico,sha256=hOHHfNDENKphQvG1WDleSEYcHukneR2eRFJu8isIlD4,74359
+pymodaq/splash.png,sha256=ow8IECF3tPRUMA4tf2tMu1aRiMaxx91_Y2ckVxkrmF0,53114
+pymodaq/control_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/control_modules/daq_move.py,sha256=CbwFwbIFTr6VV283lSeD3NwcaFfy-530GzWVVvpSDV8,35377
+pymodaq/control_modules/daq_move_ui.py,sha256=Zi5c56-dwP2VtojiUT8TJtW9EECzcyRpm9rspnyLd1Y,15219
+pymodaq/control_modules/daq_viewer.py,sha256=Pzh0poR_0Iln5PAgcIB936WKx2HsVj9jWFmTrZX2onY,57904
+pymodaq/control_modules/daq_viewer_ui.py,sha256=7XTidYrYlzj--DbbE1Wx4UBjvp1upGpziGhSTPoMKCc,15677
+pymodaq/control_modules/mocks.py,sha256=CdczKJDAuM2oL7VvIpSBWiYtTCqK_6x9unxavezp3_s,1954
+pymodaq/control_modules/move_utility_classes.py,sha256=bUK5w54hO7jTHuvhoN-etrpKd-81Zpnxq3VLKOKMvtY,33590
+pymodaq/control_modules/utils.py,sha256=4FKT8m2qOdkVOX8-xrdxDKXH0OM6pptSPDhPLfBaQ2A,20003
+pymodaq/control_modules/viewer_utility_classes.py,sha256=rYwKy9Qo6psFERKPSPo4kTzIwo8DqFwtmfIGAa9lnhQ,26699
+pymodaq/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/examples/custom_app.py,sha256=xfx-Zzvc9XotBCLR0Jb1WLk0EQr_4qm3xHRiHy46v0E,10323
+pymodaq/examples/custom_viewer.py,sha256=brNji-nTFihyOedDvu6-iYefHos0fL90D4toWMZcMuM,4799
+pymodaq/examples/function_plotter.py,sha256=z9zjvs35nwuq_Ux-EeKv4mELfVCWr1QqQG8F_AFctlk,6109
+pymodaq/examples/nonlinearscanner.py,sha256=x0R2_FP0YnuOCCAmYRiAiZ1jfUdRxu5RqIYLyGQMZ0U,3790
+pymodaq/examples/parameter_ex.py,sha256=dLw9Wmv4bTt07r0XR1zjYPujaRTUNcY-tHR9BK71nVA,8626
+pymodaq/examples/preset_MockCamera.xml,sha256=quQlMsX6YSoqqc9_9Y-9zu3TDM6Xvnuc2JSWwg9f948,15774
+pymodaq/examples/tcp_client.py,sha256=AGkLR307r11YmPej4e8WMXwAOuXpDcqeMCrWo1whiKw,2583
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.aliases,sha256=t0eKH9Uq_AMk4wQ-6Pm5mKUjGcCvfT9GtvMsvDhkCUk,47
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.lvlps,sha256=VZHH96rKSnRYKeCAXUmKI3vQOX8Wz53FYCF2yXuqnaU,84
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.lvproj,sha256=eYzmQO3XFxCJS-WMTjfyUBmmogxJUi7Nu5h64tKVlow,1984
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.vi,sha256=3O69SPlNetv7-VXpAeVDd1for0iQYPtexdd5Q_5a9To,69358
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Server_1Dgaussian.vi,sha256=VDrTmIZNkgQDIQ99WvhpDk29cziPLKejhOd3aIS4zEk,21969
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Server_2Dgaussian.vi,sha256=Yk4wYsikAyg4zTKnQReIH_Kw5mca_JiRGV5hDNzE2I8,29785
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_read_cmd.vi,sha256=DwASW4Vj20j2y6WNEyDHd2e08WYMr3w8Gz6gGwyyqx8,18148
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_read_float.vi,sha256=LZRP9jUOkQ7TMqV7my4h_MwCJ_RF4vXKpjQE6DPVqS8,20622
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_read_int.vi,sha256=vmQHX8gBhLjVeCatUoM_o0Ai92oFOoybvdPENwKsu5M,11828
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_send_data.vi,sha256=fq53wXWWLaw6y02R1Wff0oUvKJvrPWIJKdSMmh7xG94,23025
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_send_int.vi,sha256=uxMD-Jn-xDmhQlaB6DgbhADzfpRCuJ6eG01Qy2f3ZzE,9072
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_send_scalar.vi,sha256=uYnMjYMQdfQqRugCtwgKM-IGpxw_M_vGM2oUBwj-UnM,19039
+pymodaq/examples/Labview_TCP_Client/DAQ_TCP_send_string.vi,sha256=hdHU78daP5EOrX-co1TofhMLcKMQ9ODGXKcFx_IScGM,19791
+pymodaq/examples/Labview_TCP_Client/client_state.ctl,sha256=IxYi5Og0QXFB1e0VeBL23sIOYOCImf7uMzitIuPlagw,4293
+pymodaq/examples/Labview_TCP_Client/cmd_types.ctl,sha256=gwuDyGcte11Zqx0C-U8ljRyYCQleUPh18MYqg9GtxPg,4618
+pymodaq/extensions/__init__.py,sha256=PXelEHNgMwhjWlvxwObYU1joSLJnaIsFBZs9ZTR8w5c,470
+pymodaq/extensions/console.py,sha256=kkuHHog_a2Y_5cYrAFTD7IGRQ4BA4NBQz4hrwFYanQY,2277
+pymodaq/extensions/daq_scan.py,sha256=yJKRDrH71dZPix8M8qeHfRDDILmkY2vaMSdrS2J7QcQ,49331
+pymodaq/extensions/daq_scan_ui.py,sha256=vrIIm6ev21iIIKFdXM6uZiBwJU717XC8PvudjxmjPM0,10119
+pymodaq/extensions/h5browser.py,sha256=7WbF2hj7sdU0kCqTxB4nXvfKGqUnoIsa2_AhCtCBNQo,1131
+pymodaq/extensions/utils.py,sha256=F5my3dPLqDrfsIYrdqDetdyNLS6hL8LKXjoltgug8fU,1897
+pymodaq/extensions/bayesian/__init__.py,sha256=QMV9tq8Axi6YjoGj4UguBO8Zvuh26r5s91bm6YU7Itk,55
+pymodaq/extensions/bayesian/bayesian_optimisation.py,sha256=B-_upVsBuZaWlHDvRYsGspHyQh52nkL2tPchvPnZuJI,30002
+pymodaq/extensions/bayesian/utils.py,sha256=4CniISXJKwmYiN6-utZYnpIfFLU8SLSH7HxjArqLlMw,15384
+pymodaq/extensions/daq_logger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/extensions/daq_logger/abstract.py,sha256=I-t-2nSIVHHUfHJ-3IoqsuULZiIsXRe4saotaEL3-Fk,1095
+pymodaq/extensions/daq_logger/daq_logger.py,sha256=HU6rs8FxsnKMZaYVsvikowmXjlvDqwLxZxzzYYLoh9A,18451
+pymodaq/extensions/daq_logger/h5logging.py,sha256=Z512PrN4HyKMgqZ7sStFRoY1u2Baiau7X4II5Mb4Ofo,2434
+pymodaq/extensions/daq_logger/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/extensions/daq_logger/db/db_logger.py,sha256=E607KSCloojpAa9QObhaLAe1tKfh0qEkDLrafElM8rc,10460
+pymodaq/extensions/daq_logger/db/db_logger_models.py,sha256=r9672aG8vUPqtHq6gFSuIFP-7hf8HhJavsRZrYo20Ns,3461
+pymodaq/extensions/pid/__init__.py,sha256=mAua3boQaY2hS18jCn3ECVF8O1-u9XxJ6ZYPPioT118,518
+pymodaq/extensions/pid/daq_move_PID.py,sha256=LgPDBwBrdypZkQsNY_NaYVhdIkOzZUWzyuHMBle1pFc,3088
+pymodaq/extensions/pid/pid_controller.py,sha256=qAJWBFoUXHuB2JNBYkf3xOOwtXkvxzvTI2wTQIhDvdk,28372
+pymodaq/extensions/pid/utils.py,sha256=TqMOL-Xf28SGl70VwB0ORuKS4-SmbBwUdDKlEWt2zwQ,7971
+pymodaq/post_treatment/__init__.py,sha256=xaaLFZJ7OLqI_7yPurFk89A7m2ywSbYDXAsdE-QQ8Zg,81
+pymodaq/post_treatment/load_and_plot.py,sha256=dqDhZv_g3YY_Ah8bJ6OoOfPxR5xb-CuggbzlfSkPMvU,12158
+pymodaq/post_treatment/daq_measurement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.py,sha256=1u7hWDaiwsZE56c0eDTUw6qfuezoxji_QaIjkcNx0eg,7438
+pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.ui,sha256=PyzbCWPMkh5oIYYteZczXyWMeHKW9EJmM1QlzXhnyTk,7037
+pymodaq/post_treatment/daq_measurement/daq_measurement_main.py,sha256=CAKwcWMOD86aXB8mbdxOK7e8nZRos5d59FzDtqK1QoY,17093
+pymodaq/post_treatment/daq_measurement/process_from_QtDesigner_DAQ_Measurement_GUI.bat,sha256=e1tu2A67MS9fk3jhriF6saQgRxWIucIvNW92iWXFP6E,164
+pymodaq/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/resources/preset_default.xml,sha256=3OMyj4d0SeArDNcgT41JHUWSEuITM56QsP3CHgLhhqQ,26382
+pymodaq/resources/setup_plugin.py,sha256=yab26FHPB-zsUZ6ZiKQ7Rm9H1ZhoZW8RQoW4wPK-T94,3130
+pymodaq/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/utils/array_manipulation.py,sha256=lU-MwuAIv0ZFc0_E11w0TSX5AfGarJOG58yIZZk36GY,272
+pymodaq/utils/calibration_camera.py,sha256=WTRXFbacR5tL01rFH1JZ5ejEXGcxOVUM8kRA5GPyCc8,8869
+pymodaq/utils/chrono_timer.py,sha256=857iYyD_K27UyL4wPj38Ht0X9KiY-SbRd7j_1kjUF8k,7205
+pymodaq/utils/config.py,sha256=w0EkWEvUbLCq7nTNZQccaMWVILuFaGW1JsIgX3VIKKc,1155
+pymodaq/utils/conftests.py,sha256=3Ak8WEpa3EhAp73Yb1LLq8YFONhPqiL7gG9eSDIoTNc,58
+pymodaq/utils/daq_utils.py,sha256=noKCkWmDtXkbXzx5rljBDgRBBB9BhxoRQ1ICrmczpLA,5954
+pymodaq/utils/data.py,sha256=cU44xkLS2en9wzF0xjZupoaXFkix2evA7XjKggf5b3c,4393
+pymodaq/utils/exceptions.py,sha256=xWORkqBplDEKI3t5N4LEYPlowlxIs9E007AtYe4E8Y4,627
+pymodaq/utils/logger.py,sha256=6x5BPpWXw1zW2M7F4lRGIOP2TtnqJHz2m7XSqI8g0u0,293
+pymodaq/utils/math_utils.py,sha256=uBnk15-O2ucoF0dH-f41HqQYWIFsqNdkCb7AngwN8BI,248
+pymodaq/utils/gui_utils/__init__.py,sha256=MUGjejjsXUzTtDTqDzaQTL9W8Sc850ZZxYBlJn6xlxg,539
+pymodaq/utils/gui_utils/loader_utils.py,sha256=7sfAvktORgF1DAcYCHsWrl57koaO8v4D4UCqXgUPxbU,1301
+pymodaq/utils/gui_utils/utils.py,sha256=S2lRoGwVwS9VFRE3Ap3MX0tByHW_d4TUbetneg_KSgc,543
+pymodaq/utils/h5modules/__init__.py,sha256=daEdpEyAJIa8b2VkCqSKcw8PaExcB6Qro80XNes_sHA,2
+pymodaq/utils/h5modules/module_saving.py,sha256=wGI4eHKvcHOyfJ4MTclKIpqIM8MOlBYNBvqqs6nV3qA,14112
+pymodaq/utils/leco/__init__.py,sha256=PVxGVZx5uHCsZmFWrVTkVX1lE5C2V95bKBj0vK9KZQU,878
+pymodaq/utils/leco/daq_move_LECODirector.py,sha256=RSIcHolo-eH5dSi04_6zLZHZaPYmf-KdHuWDi562XrU,6376
+pymodaq/utils/leco/daq_xDviewer_LECODirector.py,sha256=7dZBGWzD4qlQxrPk9CgMQgVcHxlabnujGfhUn-kSN7I,5984
+pymodaq/utils/leco/desktop.ini,sha256=2zopClaSQqdFfIsC8CGo2Oc-14x9h1gV0-fUrDtLFmA,82
+pymodaq/utils/leco/director_utils.py,sha256=0inrKh5aI-1pQs3fTXYvmjvwZ6TiyEEAupr2Hw_pMj0,2105
+pymodaq/utils/leco/leco_director.py,sha256=TVd8DNKGoq7Uh9P5JNHFBDt1Q0VxIYPweciDbpTpa8M,3046
+pymodaq/utils/leco/pymodaq_listener.py,sha256=MIp5pAYO5ZaeXBkBtZycKP24OS3q91Nw_a13yFwPXY8,10693
+pymodaq/utils/leco/utils.py,sha256=Hx0ulVmZyYgBNNqWrGacqYt4Djr2376o-DSdX0D81I4,1394
+pymodaq/utils/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq/utils/managers/batchscan_manager.py,sha256=rhz2qeVfePX0h8sjIY1tHQckIHIxKhH-zOIzvM0_1Ag,13666
+pymodaq/utils/managers/modules_manager.py,sha256=hD6zfRIDTPNcv7J5_souTGnNT3PJjjpUmS9FAVPKANU,20738
+pymodaq/utils/managers/overshoot_manager.py,sha256=6xcl9ZGbMcUSSYSu7GesZHbyANEYlwQAno72t_DvO8g,7058
+pymodaq/utils/managers/preset_manager.py,sha256=36ojPlAUjvlDTL4cAWrnR0RQ2pWNmxbkZoDVZwCEXJY,9472
+pymodaq/utils/managers/preset_manager_utils.py,sha256=X4s6Wz4JI-fDsplyf9qE6INfEV_nZ53cm1damPvjiFQ,8105
+pymodaq/utils/managers/remote_manager.py,sha256=LuigmTfFuu9HupV0MWJ0kpVVOjyboCfRSf3HOkim_oQ,22160
+pymodaq/utils/parameter/__init__.py,sha256=SuuIhV7A1zQyxj6j1ppFJKyTYXT2v3stdDXOr6uD5BI,285
+pymodaq/utils/parameter/utils.py,sha256=atxN31PFrLDPjpX0ITEL_ugBvreOVI-RfjbOU_YCMhw,247
+pymodaq/utils/scanner/__init__.py,sha256=LqY1QwGnJEgr8CcW8uLWzbWy55Nvkmjmww4nl7xMpYU,171
+pymodaq/utils/scanner/scan_config.py,sha256=GJeH8oeZ_zMtujwkLM1jpKDQFLFKIN1wlkxXbOv6nWM,325
+pymodaq/utils/scanner/scan_factory.py,sha256=fu4kQrAoYsXeVg1VlHT2cyLZTuCQBJcz6X97CgMb0kw,8577
+pymodaq/utils/scanner/scan_selector.py,sha256=uu55xcijjg1fcvF59VVbtRLzXLoxb_3klEJPLiAuyws,16319
+pymodaq/utils/scanner/scanner.py,sha256=QxQwkkGpJvBfaoUQHGX6EK2EbIQGQFj47qBd8VQ7A0k,10898
+pymodaq/utils/scanner/utils.py,sha256=YjjrWWKs9q_OgP5xK277IyEsMqp15qFxU19kQ8f5R-c,3680
+pymodaq/utils/scanner/scanners/_1d_scanners.py,sha256=ArT1H8zl1_TztvxelDhjviEBtyv4AOO9Rt54EMKIuuQ,7812
+pymodaq/utils/scanner/scanners/_2d_scanners.py,sha256=AAHHHgyMtkXQTWnuPh3IY5ytATG5Lqc-AHJRpXIYApw,13851
+pymodaq/utils/scanner/scanners/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pymodaq/utils/scanner/scanners/sequential.py,sha256=X0slsfHCqid7N0Kj6EVeV8gStljlow2rZxPpRqj5VB4,8053
+pymodaq/utils/scanner/scanners/tabular.py,sha256=QPwW1kmJQY2YK4-clYd3r3Loolk3QYrkR2RqMIrrEvc,12752
+pymodaq/utils/svg/__init__.py,sha256=QWpeotkNhAQkoVTdWBH8t6MRr9-lrPJx4bXn7J6fCNA,81
+pymodaq/utils/svg/svg_renderer.py,sha256=USEcrOWmQAq8UM620e_XIGPI6z9IQmhyJuqbPo3jLzE,406
+pymodaq/utils/svg/svg_view.py,sha256=bmXpDqnw9S-Bp3F8Hi_oeYB5Y9gebiCNsQWVJzCq-PA,901
+pymodaq/utils/svg/svg_viewer2D.py,sha256=HbJKT90bu1fTY1m018NBtXCZGBXnGNAFemBDrMxc0PY,1427
+pymodaq/utils/tcp_ip/__init__.py,sha256=1e_EK0AgvdoLAD_CSGGEaITZdy6OWCO7ih9IAIp7HT4,81
+pymodaq/utils/tcp_ip/mysocket.py,sha256=StAWj8dzHeMnbLj68Sel81uWFy-YkKVNRnVf7gXrESI,3452
+pymodaq/utils/tcp_ip/serializer.py,sha256=SR8o_tB_keXWvYgNLYyMJhlKoXmlrM2QynbfopNP-7E,27650
+pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=cNWWfMuiWlS53d1boEBWPz37Y40n5DS-Ebiw2fYiOsU,30649
+pymodaq-5.0.0.dist-info/METADATA,sha256=H0azQSIVc3WPtJjcM58K3wzGoS-eBg3Lfqm60DPfGD0,7699
+pymodaq-5.0.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq-5.0.0.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-5.0.0.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-5.0.0.dist-info/RECORD,,

pymodaq/post_treatment/process_to_scalar.py

@@ -1,263 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 04/11/2022
-
-@author: Sebastien Weber
-"""
-import numpy as np
-from numbers import Number
-from typing import List, Tuple
-from abc import ABCMeta, abstractmethod, abstractproperty
-
-from pymodaq.utils.factory import ObjectFactory
-from pymodaq.utils import math_utils as mutils
-from pymodaq.utils.data import DataWithAxes, Axis, DataRaw, DataBase, DataDim, DataCalculated
-
-
-config_processors = {
-}
-
-
-class DataProcessorBase(metaclass=ABCMeta):
-    """Apply processing functions to signal data. This function should return a DataWithAxes.
-
-    Attributes
-    ----------
-    apply_to: DataDim
-        Specify on which type of data dimensionality this processor can be applied to, if only 1D:
-        apply_to = DataDim['Data1D']
-
-    """
-
-    apply_to: DataDim = abstractproperty
-
-    def process(self, data: DataWithAxes) -> DataWithAxes:
-        return self.operate(data)
-
-    @abstractmethod
-    def operate(self, sub_data: DataWithAxes):
-        pass
-
-    @staticmethod
-    def flatten_signal_dim(sub_data: DataWithAxes) -> Tuple[Tuple, np.ndarray]:
-        """flattens data's ndarrays along the signal dimensions"""
-        data_arrays = []
-        new_shape = [sub_data.shape[ind] for ind in sub_data.nav_indexes]
-        new_shape.append(np.prod([sub_data.shape[ind] for ind in sub_data.sig_indexes]))
-
-        # for each data in subdata, apply the function, here argmax, along the flattened dimension. Then unravel the
-        # possible multiple indexes (1 for 1D, 2 for 2D)
-        for ind, data in enumerate(sub_data):
-            data_arrays.append(data.reshape(new_shape))
-        return new_shape, data_arrays
-
-    def __call__(self, **kwargs):
-        return self(**kwargs)
-
-
-class DataProcessorFactory(ObjectFactory):
-    def get(self, processor_name, **kwargs) -> DataProcessorBase:
-        return self.create(processor_name, **kwargs)
-
-    @property
-    def functions(self):
-        """Get the list of processor functions"""
-        return self.keys_function(do_sort=False)
-
-    def functions_filtered(self, dim: DataDim):
-        """Get the list of processor functions that could be applied to data having a given dimensionality"""
-        return [key for key in self.functions if self.get(key).apply_to >= dim]
-
-
-@DataProcessorFactory.register('mean')
-class MeanProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        data_arrays = [np.atleast_1d(np.mean(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
-
-
-@DataProcessorFactory.register('std')
-class StdProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        data_arrays = [np.atleast_1d(np.std(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
-
-
-@DataProcessorFactory.register('sum')
-class SumProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        data_arrays = [np.atleast_1d(np.sum(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
-
-
-@DataProcessorFactory.register('max')
-class MaxProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        data_arrays = [np.atleast_1d(np.max(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
-
-
-@DataProcessorFactory.register('min')
-class MinProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        data_arrays = [np.atleast_1d(np.min(data, axis=sub_data.sig_indexes)) for data in sub_data]
-        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
-
-
-@DataProcessorFactory.register('argmax')
-class ArgMaxProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        """Extract info from sub-DataWithAxes
-
-        Retrieve the signal axis values of the maximum position of the data
-
-        Notes
-        -----
-        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
-        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
-        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
-        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
-        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
-        """
-        new_data_arrays = []
-        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
-
-        for dat in flattened_arrays:
-            indexes = np.unravel_index(np.nanargmax(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
-            # from the unraveled index, retrieve the corresponding axis value
-            for ind in range(len(indexes)):
-                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
-                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
-        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
-                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
-                              distribution=sub_data.distribution)
-
-
-@DataProcessorFactory.register('argmin')
-class ArgMinProcessor(DataProcessorBase):
-    apply_to = DataDim['DataND']
-
-    def operate(self, sub_data: DataWithAxes):
-        """Extract info from sub-DataWithAxes
-
-        Retrieve the signal axis values of the minimum position of the data
-
-        Notes
-        -----
-        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
-        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
-        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
-        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
-        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
-        """
-        new_data_arrays = []
-        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
-
-        for dat in flattened_arrays:
-            indexes = np.unravel_index(np.nanargmin(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
-            # from the unraveled index, retrieve the corresponding axis value
-            for ind in range(len(indexes)):
-                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
-                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
-        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
-                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
-                              distribution=sub_data.distribution)
-
-
-@DataProcessorFactory.register('argmean')
-class ArgMeanProcessor(DataProcessorBase):
-    apply_to = DataDim['Data1D']
-
-    def operate(self, sub_data: DataWithAxes):
-        """Extract info from sub-DataWithAxes
-
-        Retrieve the signal mean axis values
-
-        Notes
-        -----
-        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
-        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
-        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
-        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
-        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
-        """
-        new_data_arrays = []
-        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
-        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
-        for dat in flattened_arrays:
-            weights = dat
-            new_data_arrays.append(np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights)))
-        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
-                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
-
-
-@DataProcessorFactory.register('argstd')
-class ArgStdProcessor(DataProcessorBase):
-    apply_to = DataDim['Data1D']
-
-    def operate(self, sub_data: DataWithAxes):
-        """Extract info from sub-DataWithAxes
-
-        Retrieve the signal mean axis values
-
-        Notes
-        -----
-        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
-        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
-        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
-        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
-        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
-        """
-        new_data_arrays = []
-        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
-        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
-        for dat in flattened_arrays:
-            weights = dat
-            w_avg = np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights))
-            new_data_arrays.append(np.atleast_1d(np.sqrt(
-                np.sum(weights * (values - w_avg) ** 2, axis=len(new_shape) - 1) /
-                np.sum(weights, axis=len(new_shape) - 1))))
-        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
-                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
-
-
-if __name__ == '__main__':
-    import copy
-    processors = DataProcessorFactory()
-    print('Builders:\n'
-          f'{processors.builders}')
-
-    print('Math functions:\n'
-          f'{processors.functions}')
-
-    # test 2D signals
-    Nsigx = 200
-    Nsigy = 100
-    Nnav = 10
-    x = np.linspace(-Nsigx / 2, Nsigx / 2 - 1, Nsigx)
-    y = np.linspace(-Nsigy / 2, Nsigy / 2 - 1, Nsigy)
-
-    dat = np.zeros((Nnav, Nsigy, Nsigx))
-    for ind in range(Nnav):
-        dat[ind] = ind * mutils.gauss2D(x, 10 * (ind - Nnav / 2), 25 / np.sqrt(2),
-                                        y, 2 * (ind - Nnav / 2), 10 / np.sqrt(2))
-
-    data = DataRaw('mydata', data=[dat], nav_indexes=(0,),
-                   axes=[Axis('nav', data=np.linspace(0, Nnav-1, Nnav), index=0),
-                         Axis('sigy', data=y, index=1),
-                         Axis('sigx', data=x, index=2)])
-    new_data = processors.get('sum', **config_processors).operate(data.isig[25:75, 75:125])
-    print(new_data)
-    print(new_data.data)