pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/utils/enums.py

@@ -1,76 +1,6 @@
-from enum import Enum
-from pymodaq.utils.math_utils import find_index
-from pymodaq.utils.math_utils import my_moment
-import numpy as np
-from scipy.optimize import curve_fit
-from typing import List, Union
-
-
-class BaseEnum(Enum):
-    """Enum to be used within pymodaq with some utility methods"""
-
-    @classmethod
-    def names(cls) -> List[str]:
-        """Returns all the names of the enum"""
-        return list(cls.__members__.keys())
-
-    @classmethod
-    def values(cls) -> List[str]:
-        """Returns all the names of the enum"""
-        return [cls[name].value for name in cls.names()]
-
-    @classmethod
-    def to_dict(cls):
-        """ Returns the enum in form of a dict with names os keys
-
-        New in 4.0.2
-        """
-        return {name: cls[name].value for name in cls.names()}
-
-    @classmethod
-    def to_dict_value(cls):
-        """ Returns the enum in form of a dict with values os keys
-
-        New in 4.0.2
-        """
-        return {cls[name].value: name for name in cls.names()}
-
-    def __eq__(self, other: Union[str, Enum]):
-        """testing for equality using the enum name"""
-        if isinstance(other, str):
-            if other == self.name:
-                return True
-        return super().__eq__(other)
-
-
-def enum_checker(enum: BaseEnum, item: Union[BaseEnum, str]):
-    """Check if the item parameter is a valid enum or at least one valid string name of the enum
-
-    If a string, transforms it to a valid enum (case not important)
-
-    Parameters
-    ----------
-    enum: BaseEnum class or one of its derivated class
-
-    item: str or BaseEnum instance
-
-    Returns
-    -------
-    BaseEnum class or one of its derivated class
-    """
-
-    if not isinstance(item, enum):
-        if not isinstance(item, str):
-            raise ValueError(f'{item} is an invalid {enum}. Should be a {enum} enum or '
-                             f'a string in {enum.names()}')
-        for ind, name in enumerate(enum.names()):
-            if item.lower() == name.lower():
-                item = enum[name]
-                break
-        else:
-            raise ValueError(f'{item} is an invalid {enum}. Should be a {enum} enum or '
-                             f'a string in {enum.names()}')
-    return item
-
+from pymodaq_utils.enums import *
 
+from pymodaq_utils.warnings import deprecation_msg
 
+deprecation_msg('Importing enums stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_utils.enums module')

pymodaq/utils/exceptions.py

@@ -19,10 +19,6 @@ class MasterSlaveError(Exception):
     pass
 
 
-class ViewerError(Exception):
-    pass
-
-
 class ExpectedError(Exception):
     """Raised in the tests made for pymodaq plugins"""
     pass

pymodaq/utils/gui_utils/__init__.py

@@ -1,10 +1,10 @@
-from .dock import Dock, DockArea
-from .list_picker import ListPicker
-from .custom_app import CustomApp
-from .file_io import select_file
-from .widgets.table import TableView, TableModel, SpinBoxDelegate, BooleanDelegate
-from .widgets.push import PushButtonIcon, EditPush, EditPushRel, EditPushInfo
-from .widgets.qled import QLED
-from .widgets.spinbox import QSpinBox_ro
+from pymodaq_gui.utils.dock import Dock, DockArea
+from pymodaq_gui.utils.list_picker import ListPicker
+from pymodaq_gui.utils.custom_app import CustomApp
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.utils.widgets.table import TableView, TableModel, SpinBoxDelegate, BooleanDelegate
+from pymodaq_gui.utils.widgets.push import PushButtonIcon, EditPush, EditPushRel, EditPushInfo
+from pymodaq_gui.utils.widgets.qled import QLED
+from pymodaq_gui.utils.widgets.spinbox import QSpinBox_ro
 
 from .utils import get_splash_sc

pymodaq/utils/gui_utils/loader_utils.py

@@ -5,9 +5,30 @@ from qtpy import QtWidgets
 from pymodaq.dashboard import DashBoard
 from pymodaq.utils.gui_utils import DockArea
 from pymodaq.utils.config import get_set_preset_path
+from pymodaq.extensions.utils import CustomExt
 
 
-def load_dashboard_with_preset(preset_name: str, extension_name: str):
+def load_dashboard_with_preset(preset_name: str, extension_name: str) -> \
+        (DashBoard, CustomExt, QtWidgets.QMainWindow):
+    """ Load the Dashboard using a given preset then load an extension
+
+    Parameters
+    ----------
+    preset_name: str
+        The filename (without extension) defining the preset to be loaded in the Dashboard
+    extension_name: str
+        The name of the extension. Either the builtins ones:
+        * 'DAQScan'
+        * 'DAQLogger'
+        * 'DAQ_PID'
+        * 'Bayesian'
+
+        or the ones defined within a plugin
+
+    Returns
+    -------
+
+    """
     win = QtWidgets.QMainWindow()
     area = DockArea()
     win.setCentralWidget(area)
@@ -26,6 +47,10 @@ def load_dashboard_with_preset(preset_name: str, extension_name: str):
             extension = dashboard.load_scan_module()
         elif extension_name == 'DAQLogger':
             extension = dashboard.load_log_module()
+        elif extension_name == 'DAQ_PID':
+            extension = dashboard.load_pid_module()
+        elif extension_name == 'Bayesian':
+            extension = dashboard.load_bayesian()
         else:
             extension = dashboard.load_extension_from_name(extension_name)
     else:

pymodaq/utils/gui_utils/utils.py

@@ -1,172 +1,18 @@
-import sys
+from pymodaq_utils.config import Config
+from pymodaq_utils.logger import set_logger, get_module_name
 
-from qtpy.QtCore import QObject, Signal, QEvent, QBuffer, QIODevice, Qt
-from qtpy import QtWidgets, QtCore, QtGui
+from pymodaq_gui.utils.splash import get_splash_sc
 
-from pathlib import Path
-from pymodaq.utils.config import Config
-from pymodaq.utils.logger import set_logger, get_module_name
-from pyqtgraph import mkQApp as mkQApppg
 
 config = Config()
 logger = set_logger(get_module_name(__file__))
 
+from pymodaq_utils.warnings import deprecation_msg
 
-dashboard_submodules_params = [
-    {'title': 'Save 2D datas and above:', 'name': 'save_2D', 'type': 'bool', 'value': True},
-    {'title': 'Save raw datas only:', 'name': 'save_raw_only', 'type': 'bool', 'value': True, 'tooltip':
-        'if True, will not save extracted ROIs used to do live plotting, only raw datas will be saved'},
-    {'title': 'Do Save:', 'name': 'do_save', 'type': 'bool', 'default': False, 'value': False},
-    {'title': 'N saved:', 'name': 'N_saved', 'type': 'int', 'default': 0, 'value': 0, 'visible': False},
-]
+deprecation_msg('Importing get_splash_sc stuff from pymodaq is deprecated '
+                'in pymodaq>5.0.0,'
+                'please use the same method from the '
+                'pymodaq_gui.utils.splash module')
 
-def get_splash_sc():
-    here = Path(__file__)
-    splash_sc = QtWidgets.QSplashScreen(QtGui.QPixmap(str(here.parent.parent.parent.joinpath('splash.png'))),
-                                        Qt.WindowStaysOnTopHint)
-    return splash_sc
 
 
-def clickable(widget):
-    class Filter(QObject):
-        clicked = Signal()
-
-        def eventFilter(self, obj, event):
-            if obj == widget:
-                if event.type() == QEvent.MouseButtonRelease:
-                    if obj.rect().contains(event.pos()):
-                        self.clicked.emit()
-                        # The developer can opt for .emit(obj) to get the object within the slot.
-                        return True
-            return False
-
-    filter = Filter(widget)
-    widget.installEventFilter(filter)
-    return filter.clicked
-
-
-def h5tree_to_QTree(base_node, base_tree_elt=None, pixmap_items=[]):
-    """
-        | Convert a loaded h5 file to a QTreeWidgetItem element structure containing two columns.
-        | The first is the name of the h5 current node, the second is the path of the node in the h5 structure.
-        |
-        | Recursive function discreasing on base_node.
-
-        ==================   ======================================== ===============================
-        **Parameters**        **Type**                                 **Description**
-
-          *h5file*            instance class File from tables module   loaded h5 file
-
-          *base_node*         pytables h5 node                         parent node
-
-          *base_tree_elt*     QTreeWidgetItem                          parent QTreeWidgetItem element
-        ==================   ======================================== ===============================
-
-        Returns
-        -------
-        QTreeWidgetItem
-            h5 structure copy converted into QtreeWidgetItem structure.
-
-        See Also
-        --------
-        h5tree_to_QTree
-
-    """
-
-    if base_tree_elt is None:
-        base_tree_elt = QtWidgets.QTreeWidgetItem([base_node.name, "", base_node.path])
-    for node_name, node in base_node.children().items():
-        child = QtWidgets.QTreeWidgetItem([node_name, "", node.path])
-        if 'pixmap' in node.attrs.attrs_name:
-            pixmap_items.append(dict(node=node, item=child))
-        klass = node.attrs['CLASS']
-        if klass == 'GROUP':
-            h5tree_to_QTree(node, child, pixmap_items)
-
-        base_tree_elt.addChild(child)
-    return base_tree_elt, pixmap_items
-
-
-def set_enable_recursive(children, enable=False):
-    """Apply the enable state on all children widgets, do it recursively
-
-    Parameters
-    ----------
-    children: (list) elements children ofa pyqt5 element
-    enable: (bool) set enabled state (True) of all children widgets
-    """
-    for child in children:
-        if not children:
-            return
-        elif isinstance(child, QtWidgets.QSpinBox) or isinstance(child, QtWidgets.QComboBox) or \
-                isinstance(child, QtWidgets.QPushButton) or isinstance(child, QtWidgets.QListWidget):
-            child.setEnabled(enable)
-        else:
-            set_enable_recursive(child.children(), enable)
-
-
-def widget_to_png_to_bytes(widget, keep_aspect=True, width=200, height=100):
-    """
-    Renders the widget content in a png format as a bytes string
-    Parameters
-    ----------
-    widget: (QWidget) the widget to render
-    keep_aspect: (bool) if True use width and the widget aspect ratio to calculate the height
-                        if False use set values of width and height to produce the png
-    width: (int) the rendered width of the png
-    height: (int) the rendered width of the png
-
-    Returns
-    -------
-    binary string
-
-    """
-    png = widget.grab().toImage()
-    wwidth = widget.width()
-    wheight = widget.height()
-    if keep_aspect:
-        height = width * wheight / wwidth
-
-    png = png.scaled(int(width), int(height), QtCore.Qt.KeepAspectRatio)
-    buffer = QtCore.QBuffer()
-    buffer.open(QtCore.QIODevice.WriteOnly)
-    png.save(buffer, "png")
-    return buffer.data().data()
-
-
-def pngbinary2Qlabel(databinary, scale_height: int = None):
-    buff = QBuffer()
-    buff.open(QIODevice.WriteOnly)
-    buff.write(databinary)
-    dat = buff.data()
-    pixmap = QtGui.QPixmap()
-    pixmap.loadFromData(dat, 'PNG')
-    if scale_height is not None and isinstance(scale_height, int):
-        pixmap = pixmap.scaledToHeight(scale_height)
-    label = QtWidgets.QLabel()
-    label.setPixmap(pixmap)
-    return label
-
-
-def start_qapplication() -> QtWidgets.QApplication:
-    app = QtWidgets.QApplication(sys.argv)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
-    return app
-
-
-def mkQApp(name: str):
-    app = mkQApppg(name)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
-    return app
-
-
-def exec():
-    app = mkQApp()
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
-    return app.exec() if hasattr(app, 'exec') else app.exec_()

pymodaq/utils/gui_utils/widgets/lcd.py

@@ -1,111 +1,8 @@
-from typing import List
+from pymodaq_gui.utils.widgets.lcd import LCD
 
-import numpy as np
+from pymodaq_utils.warnings import deprecation_msg
 
-from qtpy import QtWidgets
-from qtpy.QtCore import QObject
-from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
-from pymodaq.utils.data import DataRaw
-import sys
-
-
-class LCD(QObject):
-
-    def __init__(self, parent: QtWidgets.QWidget, **kwargs):
-        super().__init__()
-        self.Nvals = None
-        self.labels = None
-        self.parent = parent
-        self.viewer0D = None
-        self.digits = 3
-        self.setupui(**kwargs)
-
-    def setvalues(self, values: List[np.ndarray]):
-        """
-        display values on lcds
-        Parameters
-        ----------
-        values: list of 0D ndarray
-
-        Returns
-        -------
-
-        """
-        while len(values) < self.Nvals:
-            values.append(np.array([0.]))
-        if len(values) > self.Nvals:
-            values = values[:self.Nvals]
-        vals = []
-        for ind, val in enumerate(values):
-            self.lcds[ind].display(val[0])
-            vals.append(val)
-        self.viewer0D.show_data(DataRaw(name='LCD', data=values))
-
-    def setupui(self, **kwargs):
-        if 'digits' in kwargs:
-            self.digits = kwargs['digits']
-        if 'Nvals' in kwargs:
-            self.Nvals = kwargs['Nvals']
-        else:
-            self.Nvals = 1
-        if 'labels' in kwargs:
-            self.labels = kwargs['labels']
-        else:
-            self.labels = ['CH{:d}'.format(ind) for ind in range(self.Nvals)]
-
-        while len(self.labels) < self.Nvals:
-            self.labels.append('')
-
-        vlayout = QtWidgets.QVBoxLayout()
-        hsplitter = QtWidgets.QSplitter()
-        vlayout.addWidget(hsplitter)
-        self.parent.setLayout(vlayout)
-        form = QtWidgets.QWidget()
-        self.viewer0D = Viewer0D(form)
-        self.viewer0D.labels = self.labels
-
-        vlayout = QtWidgets.QVBoxLayout()
-
-        lcd_layouts = []
-        labels = []
-        self.lcds = []
-
-        for ind in range(self.Nvals):
-            lcd_layouts.append(QtWidgets.QVBoxLayout())
-            labels.append(QtWidgets.QLabel(self.labels[ind]))
-            labels[-1].setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Maximum)
-            self.lcds.append(QtWidgets.QLCDNumber())
-            self.lcds[-1].setDigitCount(self.digits)
-            lcd_layouts[-1].addWidget(labels[-1])
-            lcd_layouts[-1].addWidget(self.lcds[-1])
-            vlayout.addLayout(lcd_layouts[-1])
-
-            if ind != self.Nvals - 1:
-                hFrame = QtWidgets.QFrame()
-                hFrame.setFrameShape(QtWidgets.QFrame.HLine)
-                vlayout.addWidget(hFrame)
-
-        lcd_widget = QtWidgets.QWidget()
-        lcd_widget.setLayout(vlayout)
-        hsplitter.addWidget(lcd_widget)
-        hsplitter.addWidget(form)
-        self.parent.resize(800, 500)
-        hsplitter.setSizes([400, 300])
-
-
-if __name__ == '__main__':
-    from pymodaq.utils.math_utils import gauss1D
-    import numpy as np
-
-    x = np.linspace(0, 200, 201)
-    y1 = gauss1D(x, 75, 25)
-    y2 = gauss1D(x, 120, 50, 2)
-    app = QtWidgets.QApplication(sys.argv)
-    Form = QtWidgets.QWidget()
-
-    prog = LCD(Form, Nvals=2)
-    Form.show()
-    for ind, data in enumerate(y1):
-        prog.setvalues([np.array([data])])
-        QtWidgets.QApplication.processEvents()
-    sys.exit(app.exec_())
+deprecation_msg('Importing LCD from pymodaq is deprecated '
+                'in pymodaq>5.0.0,'
+                'please use the same method from the '
+                'pymodaq_gui.utils.widgets.lcd module')

pymodaq/utils/h5modules/__init__.py

@@ -1,6 +1,2 @@
-from . import browsing
-from .utils import register_exporter, register_exporters
-
-register_exporters()
 
 

pymodaq/utils/h5modules/module_saving.py

@@ -12,19 +12,20 @@ import xml.etree.ElementTree as ET
 
 import numpy as np
 
-from pymodaq.utils.abstract import ABCMeta, abstract_attribute, abstractmethod
-from pymodaq.utils.daq_utils import capitalize
-from pymodaq.utils.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
-from .saving import H5SaverLowLevel
-from .backends import GROUP, CARRAY, Node, GroupType
-from .data_saving import DataToExportSaver, AxisSaverLoader, DataToExportTimedSaver, DataToExportExtendedSaver
-from pymodaq.utils.parameter import ioxml
+from pymodaq_utils.abstract import ABCMeta, abstract_attribute, abstractmethod
+from pymodaq_utils.utils import capitalize
+from pymodaq_data.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
+from pymodaq_data.h5modules.saving import H5SaverLowLevel
+from pymodaq_data.h5modules.backends import GROUP, CARRAY, Node, GroupType
+from pymodaq_data.h5modules.data_saving import (DataToExportSaver, AxisSaverLoader,
+                                                DataToExportTimedSaver, DataToExportExtendedSaver)
+from pymodaq_gui.parameter import ioxml
 
 if TYPE_CHECKING:
     from pymodaq.extensions.daq_scan import DAQScan
     from pymodaq.control_modules.daq_viewer import DAQ_Viewer
     from pymodaq.control_modules.daq_move import DAQ_Move
-    from pymodaq.utils.h5modules.h5logging import H5Logger
+    from pymodaq.extensions.daq_logger.h5logging import H5Logger
 
 
 class ModuleSaver(metaclass=ABCMeta):

pymodaq/utils/leco/__init__.py

@@ -1,5 +1,5 @@
-from pymodaq.utils.logger import set_logger
-from pymodaq.utils.config import Config
+from pymodaq_utils.logger import set_logger
+from pymodaq_utils.config import Config
 
 logger = set_logger('pymodaq')
 config = Config()  # to ckeck for config file existence, otherwise create one

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -12,8 +12,8 @@ from typing import Union
 from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun, main,
                                                           DataActuatorType, DataActuator)
 
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import ActuatorDirector
@@ -38,8 +38,6 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
     settings: Parameter
     controller: ActuatorDirector
 
-    is_multiaxes = False
-    axes_names = []
     params_client = []  # parameters of a client grabber
     data_actuator_type = DataActuatorType['float']  # DataActuatorType['DataActuator']
 
@@ -47,8 +45,7 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
                                                 'get_actuator_value', 'stop_motion', 'position_is',
                                                 'move_done']
     socket_types = ["ACTUATOR"]
-    params = [
-    ] + comon_parameters_fun(is_multiaxes=is_multiaxes, axes_names=axes_names) + leco_parameters
+    params = comon_parameters_fun() + leco_parameters
 
     def __init__(self, parent=None, params_state=None, **kwargs) -> None:
         super().__init__(parent=parent,

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -5,8 +5,8 @@ from easydict import EasyDict as edict
 
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
 
-from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand, getLineInfo
+from pymodaq_gui.parameter import Parameter
 from pymodaq.utils.tcp_ip.serializer import DeSerializer
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
@@ -29,8 +29,7 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
                                                 "Status", "Done", "Server Closed",
                                                 "Info", "Infos", "Info_xml", 'x_axis', 'y_axis']
     socket_types = ["GRABBER"]
-    params = [
-    ] + comon_parameters + leco_parameters
+    params = comon_parameters + leco_parameters
 
     def __init__(self, parent=None, params_state=None, grabber_type: str = "0D", **kwargs) -> None:
         super().__init__(parent=parent, params_state=params_state, **kwargs)
@@ -153,7 +152,8 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.y_axis = dict(data=data, label=label, units=units)
         self.emit_y_axis()
 
-    def set_data(self, data: Union[list, str, None], additional_payload: Optional[list[bytes]]=None) -> None:
+    def set_data(self, data: Union[list, str, None],
+                 additional_payload: Optional[list[bytes]]=None) -> None:
         """
         Set the grabbed data signal.
 

pymodaq/utils/leco/director_utils.py

@@ -8,8 +8,8 @@ from typing import Optional, Union, List
 
 from pyleco.directors.director import Director
 
-import pymodaq.utils.parameter.utils as putils
-from pymodaq.utils.parameter import Parameter, ioxml
+import pymodaq_gui.parameter.utils as putils
+from pymodaq_gui.parameter import Parameter, ioxml
 from pymodaq.control_modules.move_utility_classes import DataActuator
 from pymodaq.utils.leco.utils import serialize_object
 

pymodaq/utils/leco/leco_director.py

@@ -3,10 +3,10 @@ import random
 
 from typing import Callable, Sequence, List
 
-import pymodaq.utils.parameter.utils as putils
+import pymodaq_gui.parameter.utils as putils
 # object used to send info back to the main thread:
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.director_utils import GenericDirector
 from pymodaq.utils.leco.pymodaq_listener import PymodaqListener

pymodaq/utils/leco/pymodaq_listener.py

@@ -14,9 +14,10 @@ from pyleco.core import COORDINATOR_PORT
 from pyleco.utils.listener import Listener, PipeHandler
 from qtpy.QtCore import QObject, Signal  # type: ignore
 
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.tcp_ip.serializer import DataWithAxes, SERIALIZABLE, DeSerializer
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import ioxml
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.serializer_legacy import SERIALIZABLE, DeSerializer
 from pymodaq.utils.leco.utils import binary_serialization_to_kwargs
 
 

pymodaq/utils/leco/utils.py

@@ -1,27 +1,29 @@
 from __future__ import annotations
 import subprocess
 import sys
-from typing import Any, Optional, Union, get_args
-
+from typing import Any, Optional, Union, get_args, TypeVar
+from pymodaq_data import data
+from pymodaq.utils import data
 # import also the DeSerializer for easier imports in dependents
-from pymodaq.utils.tcp_ip.serializer import SERIALIZABLE, Serializer, DeSerializer  # type: ignore  # noqa
-from pymodaq.utils.logger import set_logger
+from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SerializableFactory
+# type: ignore  # noqa
+from pymodaq_utils.logger import set_logger
 
 
 logger = set_logger('leco_utils')
-
+ser_factory = SerializableFactory()
 JSON_TYPES = Union[str, int, float]
 
+SERIALIZABLE = ser_factory.get_serializables()
+
 
 def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
     """Serialize a pymodaq object, if it is not JSON compatible."""
     if isinstance(pymodaq_object, get_args(JSON_TYPES)):
         return pymodaq_object
-    elif isinstance(pymodaq_object, get_args(SERIALIZABLE)):
-        return Serializer(pymodaq_object).to_b64_string()
     else:
-        raise ValueError(f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
-                         "JSON serializable, nor via PyMoDAQ.")
+        return Serializer(pymodaq_object).to_b64_string() # will raise a proper error if the object
+    #is not serializable
 
 
 def binary_serialization(