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

pymodaq/utils/scanner/scan_config.py

@@ -11,14 +11,6 @@ from pymodaq.utils.config import BaseConfig, getitem_recursive
 
 class ScanConfig(BaseConfig):
     """Main class to deal with configuration values for this plugin"""
-    config_template_path = Path(__file__).parent.parent.parent.joinpath('resources/config_scan_template.toml')
+    config_template_path = None
     config_name = f"scanner_settings"
 
-    def __setitem__(self, key, value):
-        if isinstance(key, tuple):
-            dic = getitem_recursive(self._config, *key, ndepth=1, create_if_missing=True)
-            if value is None:  # means the setting is a group
-                value = {}
-            dic[key[-1]] = value
-        else:
-            self._config[key] = value

pymodaq/utils/scanner/scan_factory.py

@@ -81,11 +81,14 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
         super().__init__()
         self.positions: np.ndarray = None
         self.n_steps = 1
-        self._actuators: List[DAQ_Move] = None
+        self.config = ScanConfig()
+        base_path = [act.title for act in actuators] + [self.scan_type, self.scan_subtype]
 
-        self.actuators = actuators
+        self.config_saver_loader = configmod.ConfigSaverLoader(self.settings,
+                                                               self.config,
+                                                               base_path)
 
-        self.config = ScanConfig()
+        self.actuators: List[DAQ_Move] = actuators
 
         self.set_settings_titles()
         self.set_settings_values()
@@ -93,32 +96,12 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
         if self.check_steps():
             self.set_scan()
 
-
     def set_settings_titles(self):
         """Update the settings accordingly with the selected actuators"""
         ...
 
     def set_settings_values(self, param: Parameter = None):
-        if param is None:
-            param = self.settings
-        for child in param.children():
-            if len(child.children()) == 0:  #means it is not a group parameter
-                path = self.actuators_name
-                path_scan = [self.scan_type, self.scan_subtype]
-                path_param = get_param_path(child)[1:]
-                path.extend(path_scan)
-                path.extend(path_param)
-                try:
-                    child.setValue(self.config(*path))  # first try to load the config including the actuators name
-                except configmod.ConfigError as e:
-                    try:
-                        path = path_scan
-                        path.extend(path_param)
-                        child.setValue(self.config(*path))   # then without the actuators name
-                    except Exception as e:
-                        pass
-            else:
-                self.set_settings_values(child)
+        self.config_saver_loader.load_config(param)
 
     @property
     def actuators(self) -> List[DAQ_Move]:
@@ -127,6 +110,8 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
     @actuators.setter
     def actuators(self, actuators: List[DAQ_Move]):
         self._actuators = actuators
+        base_path = self.actuators_name + [self.scan_type, self.scan_subtype]
+        self.config_saver_loader.base_path = base_path
 
     @property
     def actuators_name(self) -> List[str]:
@@ -198,18 +183,7 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
 
     def save_scan_parameters(self):
         if self.save_settings:
-            path_actuators = self.actuators_name
-            path_scan = [self.scan_type, self.scan_subtype]
-            path_actuators.extend(path_scan)
-            for param in iter_children_params(self.settings, []):
-                path = path_actuators[:]
-                path_param = get_param_path(param)[1:]
-                path.extend(path_param)
-                try:
-                    self.config[tuple(path)] = param.value()
-                except Exception as e:
-                    pass
-            self.config.save()
+            self.config_saver_loader.save_config()
 
     @abstractmethod
     def update_from_scan_selector(self, scan_selector: Selector):

pymodaq/utils/scanner/scanner.py

@@ -81,7 +81,8 @@ class Scanner(QObject, ParameterManager):
     def set_scanner(self):
         try:
             self._scanner: ScannerBase = scanner_factory.get(self.settings['scan_type'],
-                                                             self.settings['scan_sub_type'], actuators=self.actuators)
+                                                             self.settings['scan_sub_type'],
+                                                             actuators=self.actuators)
 
             while True:
                 child = self._scanner_settings_widget.layout().takeAt(0)
@@ -93,7 +94,7 @@ class Scanner(QObject, ParameterManager):
             self._scanner_settings_widget.layout().addWidget(self._scanner.settings_tree)
             self._scanner.settings.sigTreeStateChanged.connect(self._update_steps)
 
-        except ValueError:
+        except ValueError as e:
             pass
 
     @property

pymodaq/utils/scanner/scanners/_1d_scanners.py

@@ -4,7 +4,7 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple, Any
+from typing import List, Tuple, Any, TYPE_CHECKING
 import re
 import numpy as np
 from pymodaq.utils.data import Axis, DataDistribution
@@ -15,6 +15,8 @@ from pymodaq.utils.plotting.scan_selector import Selector
 
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
 
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
 
 logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
@@ -59,8 +61,8 @@ class Scan1DLinear(Scan1DBase):
     n_axes = 1
     distribution = DataDistribution['uniform']
 
-    def __init__(self, actuators: List = None, **_ignored):
-        ScannerBase.__init__(self, actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
+        super().__init__(actuators=actuators)
 
     def set_scan(self):
         self.positions = mutils.linspace_step(self.settings['start'], self.settings['stop'],
@@ -123,7 +125,7 @@ class Scan1DSparse(Scan1DBase):
     distribution = DataDistribution['uniform']  # because in 1D it doesn't matter is spread or
     # uniform, one can easily plot both types on a regulat 1D plot
 
-    def __init__(self, actuators: List = None, **_ignored):
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
         self.settings.child('parsed_string').setOpts(tip=self.__doc__)
 
@@ -176,7 +178,7 @@ try:
             ]
         distribution = DataDistribution['spread']
 
-        def __init__(self, actuators: List = None, **_ignored):
+        def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
             super().__init__(actuators=actuators)
 
         def set_scan(self):

pymodaq/utils/scanner/scanners/_2d_scanners.py

@@ -4,7 +4,7 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple
+from typing import List, Tuple, TYPE_CHECKING
 
 import numpy as np
 from pymodaq.utils.data import Axis, DataDistribution
@@ -18,6 +18,9 @@ from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
 logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
 
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
 
 class Scan2DBase(ScannerBase):    
     params = [{'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
@@ -29,7 +32,7 @@ class Scan2DBase(ScannerBase):
                 ]
     axes = ('axis1','axis2')    
     n_axes = 2
-    def __init__(self, actuators: List = None, **_ignored):
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
         self.axes_unique = []
 
@@ -40,20 +43,20 @@ class Scan2DLinear(Scan2DBase):
     params = [{'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
                'children':[
               {'title': 'Start Ax1:', 'name': 'start_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'start1')},
+               'value': 0.},
               {'title': 'Stop Ax1:', 'name': 'stop_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'stop1')},              
+               'value': 1.},
               {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'step1')},
+               'value': 0.1},
               ]}, 
               {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
                'children':[
               {'title': 'Start Ax2:', 'name': 'start_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'start2')},
+               'value': 0.},
               {'title': 'Stop Ax2:', 'name': 'stop_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'stop2')},              
+               'value': 1.},
               {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'step2')},              
+               'value': 0.1},
                ]},
               ]    
     n_axes = 2
@@ -61,13 +64,13 @@ class Scan2DLinear(Scan2DBase):
     scan_type = 'Scan2D'
     scan_subtype = 'Linear'
 
-    def __init__(self, actuators: List = None, **_ignored):        
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
 
     def get_pos(self):
-        starts = np.array([self.settings[ax,f'start_{ax}'] for ax in self.axes])
-        stops = np.array([self.settings[ax,f'stop_{ax}'] for ax in self.axes])
-        steps = np.array([self.settings[ax,f'step_{ax}'] for ax in self.axes])        
+        starts = np.array([self.settings[ax, f'start_{ax}'] for ax in self.axes])
+        stops = np.array([self.settings[ax, f'stop_{ax}'] for ax in self.axes])
+        steps = np.array([self.settings[ax, f'step_{ax}'] for ax in self.axes])
         return starts, stops, steps
 
     def evaluate_steps(self) -> int:
@@ -101,10 +104,9 @@ class Scan2DLinear(Scan2DBase):
             for i,ax in enumerate(self.axes):            
                 title = self.actuators[i].title
                 self.settings.child(ax).setOpts(title=title)                
-                self.settings.child(ax,f'start_{ax}').setOpts(title=f'{title} start:')
-                self.settings.child(ax,f'stop_{ax}').setOpts(title=f'{title} stop:')
-                self.settings.child(ax,f'step_{ax}').setOpts(title=f'{title} step:')
-
+                self.settings.child(ax, f'start_{ax}').setOpts(title=f'{title} start:')
+                self.settings.child(ax, f'stop_{ax}').setOpts(title=f'{title} stop:')
+                self.settings.child(ax, f'step_{ax}').setOpts(title=f'{title} step:')
 
     def get_nav_axes(self) -> List[Axis]:
         return [Axis(label=f'{act.title}',
@@ -127,12 +129,11 @@ class Scan2DLinear(Scan2DBase):
                 self.settings.child(ax,f'stop_{ax}').setValue(coordinates[1, i])
 
 
-
 @ScannerFactory.register()
 class Scan2DLinearBF(Scan2DLinear):
     scan_subtype = 'LinearBackForce'
 
-    def __init__(self, actuators: List = None, **_ignored):
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
 
     def set_scan(self):
@@ -162,7 +163,7 @@ class Scan2DLinearBF(Scan2DLinear):
 class Scan2DRandom(Scan2DLinear):
     scan_subtype = 'Random'
 
-    def __init__(self, actuators: List = None, **_ignored):
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
 
     def set_scan(self):
@@ -175,28 +176,28 @@ class Scan2DRandom(Scan2DLinear):
 class Scan2DSpiral(Scan2DLinear):
     scan_subtype = 'Spiral'
     params = [{'title': 'Npts/axis', 'name': 'npts_by_axis', 'type': 'int', 'min': 1,
-               'value': config('scan', 'scan2D', 'spiral', 'npts')},
+               'value': 10},
               {'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
                'children': [
                    {'title': 'Center Ax1:', 'name': 'center_axis1', 'type': 'float',
-                    'value': config('scan', 'scan2D', 'linear', 'start1')},
+                    'value': 0.},
                    {'title': 'Rmax Ax1:', 'name': 'rmax_axis1', 'type': 'float',
-                    'value': config('scan', 'scan2D', 'linear', 'stop1')},
+                    'value': 5.},
                    {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
                     'value': 0., 'readonly': True},
                ]},
               {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
                'children': [
                    {'title': 'Center Ax2:', 'name': 'center_axis2', 'type': 'float',
-                    'value': config('scan', 'scan2D', 'linear', 'start2')},
+                    'value': 0.},
                    {'title': 'Rmax Ax2:', 'name': 'rmax_axis2', 'type': 'float',
-                    'value': config('scan', 'scan2D', 'linear', 'stop2')},
+                    'value': 5.},
                    {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
                     'value': 0., 'readonly': True},
                ]},
               ]  
    
-    def __init__(self, actuators: List = None, **_ignored):
+    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
         super().__init__(actuators=actuators)
 
     def set_settings_titles(self):
@@ -204,17 +205,9 @@ class Scan2DSpiral(Scan2DLinear):
             for i,ax in enumerate(self.axes):            
                 title = self.actuators[i].title
                 self.settings.child(ax).setOpts(title=title)                
-                self.settings.child(ax,f'center_{ax}').setOpts(title=f'{title} center:')
-                self.settings.child(ax,f'rmax_{ax}').setOpts(title=f'{title} rmax:')
-                self.settings.child(ax,f'step_{ax}').setOpts(title=f'{title} step:')
-
-            
-            # self.settings.child('center_axis1').setOpts(title=f'Center {self.actuators[0].title}:')
-            # self.settings.child('rmax_axis1').setOpts(title=f'Rmax {self.actuators[0].title}:')
-            # self.settings.child('step_axis1').setOpts(title=f'Step {self.actuators[0].title}:')
-            # self.settings.child('center_axis2').setOpts(title=f'Center {self.actuators[1].title}:')
-            # self.settings.child('rmax_axis2').setOpts(title=f'Rmax {self.actuators[1].title}:')
-            # self.settings.child('step_axis2').setOpts(title=f'Step {self.actuators[1].title}:')
+                self.settings.child(ax, f'center_{ax}').setOpts(title=f'{title} center:')
+                self.settings.child(ax, f'rmax_{ax}').setOpts(title=f'{title} rmax:')
+                self.settings.child(ax, f'step_{ax}').setOpts(title=f'{title} step:')
 
     def value_changed(self, param):
         starts, rmaxs, rsteps = self.get_pos()
@@ -234,10 +227,8 @@ class Scan2DSpiral(Scan2DLinear):
         r_steps: np.ndarray
             steps size in both directions
         """
-        centers = np.array([self.settings[ax,f'center_{ax}'] for ax in self.axes])
-        rmaxs = np.array([self.settings[ax,f'rmax_{ax}'] for ax in self.axes])
-        # centers = np.array([self.settings['center_axis1'], self.settings['center_axis2']])
-        # rmaxs = np.array([self.settings['rmax_axis1'], self.settings['rmax_axis2']])
+        centers = np.array([self.settings[ax, f'center_{ax}'] for ax in self.axes])
+        rmaxs = np.array([self.settings[ax, f'rmax_{ax}'] for ax in self.axes])
         r_steps = 2 * rmaxs / self.settings['npts_by_axis']
         return centers, rmaxs, r_steps
 
@@ -290,14 +281,10 @@ class Scan2DSpiral(Scan2DLinear):
         coordinates = scan_selector.get_coordinates()
         if coordinates.shape == (2, 2):
             for i,ax in enumerate(self.axes):            
-                self.settings.child(ax,f'center_{ax}').setValue((coordinates[0, i] + coordinates[1, i]) / 2)
-                self.settings.child(ax,f'rmax_{ax}').setValue((coordinates[0, i] - coordinates[1, i]) / 2)
-            #     self.settings.child(ax,f'center_{ax}').setValue((coordinates[0, i] - coordinates[1, i]) / 2)
-            #     self.settings.child(ax,f'rmax_{ax}').setValue(coordinates[1, i])            
-            # self.settings.child('center_axis1').setValue((coordinates[0, 0] + coordinates[1, 0]) / 2)
-            # self.settings.child('center_axis2').setValue((coordinates[0, 1] + coordinates[1, 1]) / 2)
-            # self.settings.child('rmax_axis1').setValue(abs(coordinates[1, 0] - coordinates[0, 0]) / 2)
-            # self.settings.child('rmax_axis2').setValue(abs(coordinates[1, 1] - coordinates[0, 1]) / 2)
+                self.settings.child(ax, f'center_{ax}').setValue(
+                    (coordinates[0, i] + coordinates[1, i]) / 2)
+                self.settings.child(ax, f'rmax_{ax}').setValue(
+                    (coordinates[0, i] - coordinates[1, i]) / 2)
 
 
 try:
@@ -333,7 +320,7 @@ try:
             ]
         distribution = DataDistribution['spread']
 
-        def __init__(self, actuators: List = None, **_ignored):
+        def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
             super().__init__(actuators=actuators)
 
         def set_scan(self):

pymodaq/utils/scanner/scanners/sequential.py

@@ -4,7 +4,7 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple
+from typing import List, Tuple, TYPE_CHECKING
 
 import numpy as np
 
@@ -23,6 +23,10 @@ logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
 
 
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
+
 class TableModelSequential(gutils.TableModel):
     """Table Model for the Model/View Qt framework dedicated to the Sequential scan mode"""
     def __init__(self, data, **kwargs):
@@ -84,7 +88,7 @@ class SequentialScanner(ScannerBase):
     distribution = DataDistribution['uniform']
     n_axes = 1
 
-    def __init__(self, actuators: List[str]):
+    def __init__(self, actuators: List['DAQ_Move']):
 
         self.table_model: TableModelSequential = None
         self.table_view: TableViewCustom = None
@@ -96,8 +100,10 @@ class SequentialScanner(ScannerBase):
         return self._actuators
 
     @actuators.setter
-    def actuators(self, actuators_name):
-        self._actuators = actuators_name
+    def actuators(self, actuators):
+        self._actuators = actuators
+        base_path = self.actuators_name + [self.scan_type, self.scan_subtype]
+        self.config_saver_loader.base_path = base_path
         self.update_model()
 
     def update_model(self, init_data=None):

pymodaq/utils/scanner/scanners/tabular.py

@@ -4,7 +4,7 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple
+from typing import List, Tuple, TYPE_CHECKING
 
 import numpy as np
 
@@ -20,6 +20,9 @@ from pymodaq.utils.parameter.pymodaq_ptypes import TableViewCustom
 from pymodaq.utils.plotting.scan_selector import Selector
 from pymodaq.utils.plotting.utils.plot_utils import Point, get_sub_segmented_positions
 
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
 
 logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
@@ -103,7 +106,7 @@ class TabularScanner(ScannerBase):
               ]
     distribution = DataDistribution['spread']
 
-    def __init__(self, actuators: List[str]):
+    def __init__(self, actuators: List['DAQ_Move']):
         self.table_model: TableModelTabular = None
         self.table_view: TableViewCustom = None
         super().__init__(actuators=actuators)
@@ -113,8 +116,10 @@ class TabularScanner(ScannerBase):
         return self._actuators
 
     @actuators.setter
-    def actuators(self, actuators_name):
-        self._actuators = actuators_name
+    def actuators(self, actuators):
+        self._actuators = actuators
+        base_path = self.actuators_name + [self.scan_type, self.scan_subtype]
+        self.config_saver_loader.base_path = base_path
         self.update_model()
 
     def update_model(self, init_data=None):
@@ -218,7 +223,7 @@ class TabularScannerSubSegmented(TabularScanner):
                'menu': True},
               ] + TabularScanner.params
 
-    def __init__(self, actuators: List[str]):
+    def __init__(self, actuators: List['DAQ_Move']):
         self.table_model: TableModelTabularReadOnly = None
         self.table_view: TableViewCustom = None
         self.table_model_points: TableModelTabular = None

pymodaq/utils/slicing.py

@@ -17,7 +17,7 @@ class SpecialSlicers(object):
         self.is_navigation = is_navigation
         self.obj = obj
 
-    def __getitem__(self, slices):
+    def __getitem__(self, slices) -> Union['DataWithAxes', 'Axis']:
         return self.obj._slicer(slices, self.is_navigation)
 
 

pymodaq/utils/tcp_ip/serializer.py

@@ -4,6 +4,7 @@ Created the 20/10/2023
 
 @author: Sebastien Weber
 """
+from base64 import b64encode, b64decode
 import numbers
 from typing import Tuple, List, Union, TYPE_CHECKING, Iterable
 
@@ -16,6 +17,18 @@ if TYPE_CHECKING:
     from pymodaq.utils.tcp_ip.mysocket import Socket
 
 
+SERIALIZABLE = Union[
+    int,
+    str,
+    numbers.Number,
+    list,
+    np.ndarray,
+    Axis,
+    DataWithAxes,
+    DataToExport,
+]
+
+
 class SocketString:
     """Mimic the Socket object but actually using a bytes string not a socket connection
 
@@ -68,9 +81,10 @@ class SocketString:
 
 
 class Serializer:
-    """Used to Serialize to bytes python objects, numpy arrays and PyMoDAQ DataWithAxes and DataToExport objects"""
+    """Used to Serialize to bytes python objects, numpy arrays and PyMoDAQ DataWithAxes and
+    DataToExport objects"""
 
-    def __init__(self, obj: Union[int, str, numbers.Number, list, np.ndarray, Axis, DataWithAxes, DataToExport] = None):
+    def __init__(self, obj: SERIALIZABLE = None):
         self._bytes_string = b''
         self._obj = obj
 
@@ -107,6 +121,11 @@ class Serializer:
             return self.list_serialization(self._obj)
         elif isinstance(self._obj, bool):
             return self.scalar_serialization(int(self._obj))
+        raise ValueError
+
+    def to_b64_string(self) -> str:
+        b = self.to_bytes()
+        return b64encode(b).decode()
 
     @staticmethod
     def int_to_bytes(an_integer: int) -> bytes:
@@ -123,17 +142,17 @@ class Serializer:
         if not isinstance(an_integer, int):
             raise TypeError(f'{an_integer} should be an integer, not a {type(an_integer)}')
         elif an_integer < 0:
-            raise ValueError(f'Can only serialize unsigned integer using this method')
+            raise ValueError('Can only serialize unsigned integer using this method')
         return an_integer.to_bytes(4, 'big')
 
     @staticmethod
     def str_to_bytes(message: str) -> bytes:
         if not isinstance(message, str):
-            raise TypeError(f'Can only serialize str object using this method')
+            raise TypeError('Can only serialize str object using this method')
         return message.encode()
 
     @classmethod
-    def str_len_to_bytes(cls, message: str) -> (bytes, bytes):
+    def str_len_to_bytes(cls, message: Union[str, bytes]) -> (bytes, bytes):
         """ Convert a string and its length to two bytes
         Parameters
         ----------
@@ -391,6 +410,7 @@ class Serializer:
         * serialize the origin
         * serialize the nav_index tuple as a list of int
         * serialize the list of axis
+        * serialize the errors attributes (None or list(np.ndarray))
         * serialize the list of names of extra attributes
         * serialize the extra attributes
         """
@@ -409,6 +429,12 @@ class Serializer:
         bytes_string += self.string_serialization(dwa.origin)
         bytes_string += self.list_serialization(list(dwa.nav_indexes))
         bytes_string += self.list_serialization(dwa.axes)
+        if dwa.errors is None:
+            errors = []  # have to use this extra attribute as if I force dwa.errors = [], it will be
+            #internally modified as None again
+        else:
+            errors = dwa.errors
+        bytes_string += self.list_serialization(errors)
         bytes_string += self.list_serialization(dwa.extra_attributes)
         for attribute in dwa.extra_attributes:
             bytes_string += self.type_and_object_serialization(getattr(dwa, attribute))
@@ -468,6 +494,10 @@ class DeSerializer:
             bytes_string = SocketString(bytes_string)
         self._bytes_string = bytes_string
 
+    @classmethod
+    def from_b64_string(cls, b64_string: Union[bytes, str]) -> "DeSerializer":
+        return cls(b64decode(b64_string))
+
     @staticmethod
     def bytes_to_string(message: bytes) -> str:
         return message.decode()
@@ -670,6 +700,9 @@ class DeSerializer:
                                             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())