pymodaq_data 5.0.5__tar.gz → 5.0.7__tar.gz

{pymodaq_data-5.0.5 → pymodaq_data-5.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq_data
-Version: 5.0.5
+Version: 5.0.7
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ

{pymodaq_data-5.0.5 → pymodaq_data-5.0.7}/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '5.0.5'
-__version_tuple__ = version_tuple = (5, 0, 5)
+__version__ = version = '5.0.7'
+__version_tuple__ = version_tuple = (5, 0, 7)

{pymodaq_data-5.0.5 → pymodaq_data-5.0.7}/src/pymodaq_data/data.py

@@ -101,6 +101,7 @@ class DataUnitError(Exception):
 
 
 class DwaType(BaseEnum):
+    """Different types of `DataWithAxes`."""
     DataWithAxes = 0
     DataRaw = 1
     DataActuator = 2
@@ -774,6 +775,13 @@ class DataBase(DataLowLevel, NDArrayOperatorsMixin):
         """ Change immediately the units to whatever else. Use this with care!"""
         self._units = units
 
+    def to_base_units(self):
+        dwa = self.deepcopy()
+        data_quantities = [quantity.to_base_units() for quantity in self.quantities]
+        dwa.data = [quantity.magnitude for quantity in data_quantities]
+        dwa.force_units(str(data_quantities[0].units))
+        return dwa
+
     def value(self, units: str = None) -> float:
         """Returns the underlying float value (of the first elt in the data list) if this data
         holds only a float otherwise returns a mean of the underlying data
@@ -905,7 +913,7 @@ class DataBase(DataLowLevel, NDArrayOperatorsMixin):
 
     def _comparison_common(self, other, operator='__eq__'):
         if isinstance(other, DataBase):
-            if not (# no more checking for name equality
+            if not (# no more checking for name equality but take care ot the pop/remove methods
                     len(self) == len(other) and
                     Unit(self.units).is_compatible_with(other.units)):
                 return False
@@ -1790,7 +1798,13 @@ class DataWithAxes(DataBase):
         should match the data ndarray
     """
 
-    def __init__(self, *args, axes: List[Axis] = [],
+    def __init__(self, name: str,
+                 source: DataSource = None, dim: DataDim = None,
+                 distribution: DataDistribution = DataDistribution.uniform,
+                 data: List[np.ndarray] = None,
+                 labels: List[str] = None, origin: str = '',
+                 units: str = '',
+                 axes: List[Axis] = [],
                  nav_indexes: Tuple[int] = (),
                  errors: Iterable[np.ndarray] = None,
                  **kwargs):
@@ -1805,7 +1819,13 @@ class DataWithAxes(DataBase):
         nav_x_axis = kwargs.pop('nav_x_axis') if 'nav_x_axis' in kwargs else None
         nav_y_axis = kwargs.pop('nav_y_axis') if 'nav_y_axis' in kwargs else None
 
-        super().__init__(*args, **kwargs)
+        super().__init__(name, source=source, dim=dim,
+                         distribution=distribution,
+                         data=data,
+                         labels=labels,
+                         origin=origin,
+                         units=units,
+                         **kwargs)
 
         self._axes = axes
 
@@ -1918,7 +1938,7 @@ class DataWithAxes(DataBase):
         is_equal = super().__eq__(other)
         if not is_equal:
             return is_equal
-        if isinstance(other, DataWithAxes):
+        if isinstance(other, self.__class__):
             for ind in list(self.nav_indexes) + list(self.sig_indexes):
                 axes_self = self.get_axis_from_index(ind)
                 axes_other = other.get_axis_from_index(ind)
@@ -2594,24 +2614,87 @@ class DataWithAxes(DataBase):
 
 class DataRaw(DataWithAxes):
     """Specialized DataWithAxes set with source as 'raw'. To be used for raw data"""
-    def __init__(self, *args,  **kwargs):
+    def __init__(self, name: str,
+                 dim: DataDim = None,
+                 distribution: DataDistribution = DataDistribution.uniform,
+                 data: List[np.ndarray] = None,
+                 labels: List[str] = None, origin: str = '',
+                 units: str = '',
+                 axes: List[Axis] = [],
+                 nav_indexes: Tuple[int] = (),
+                 errors: Iterable[np.ndarray] = None,
+                 **kwargs):
         if 'source' in kwargs:
             kwargs.pop('source')
-        super().__init__(*args, source=DataSource['raw'], **kwargs)
+
+        super().__init__(name, source=DataSource.raw,
+                         dim=dim,
+                         distribution=distribution,
+                         data=data,
+                         labels=labels,
+                         origin=origin,
+                         units=units,
+                         axes=axes,
+                         nav_indexes=nav_indexes,
+                         errors=errors,
+                         **kwargs
+                         )
 
 
 class DataCalculated(DataWithAxes):
-    """Specialized DataWithAxes set with source as 'calculated'. To be used for processed/calculated data"""
-    def __init__(self, *args, axes=[],  **kwargs):
+    """Specialized DataWithAxes set with source as 'calculated'. To be used for
+    processed/calculated data"""
+    def __init__(self, name: str,
+                 dim: DataDim = None,
+                 distribution: DataDistribution = DataDistribution.uniform,
+                 data: List[np.ndarray] = None,
+                 labels: List[str] = None, origin: str = '',
+                 units: str = '',
+                 axes: List[Axis] = [],
+                 nav_indexes: Tuple[int] = (),
+                 errors: Iterable[np.ndarray] = None,
+                 **kwargs):
+
         if 'source' in kwargs:
             kwargs.pop('source')
-        super().__init__(*args, source=DataSource['calculated'], axes=axes, **kwargs)
+        super().__init__(name, source=DataSource.calculated,
+                         dim=dim,
+                         distribution=distribution,
+                         data=data,
+                         labels=labels,
+                         origin=origin,
+                         units=units,
+                         axes=axes,
+                         nav_indexes=nav_indexes,
+                         errors=errors,
+                         **kwargs)
 
 
 class DataFromRoi(DataCalculated):
-    """Specialized DataWithAxes set with source as 'calculated'.To be used for processed data from region of interest"""
-    def __init__(self, *args, axes=[], **kwargs):
-        super().__init__(*args, axes=axes, **kwargs)
+    """Specialized DataWithAxes set with source as 'calculated'.
+    To be used for processed data from region of interest"""
+    def __init__(self, name: str,
+                 dim: DataDim = None,
+                 distribution: DataDistribution = DataDistribution.uniform,
+                 data: List[np.ndarray] = None,
+                 labels: List[str] = None, origin: str = '',
+                 units: str = '',
+                 axes: List[Axis] = [],
+                 nav_indexes: Tuple[int] = (),
+                 errors: Iterable[np.ndarray] = None,
+                 **kwargs):
+
+        super().__init__(name, source=DataSource.calculated,
+                         dim=dim,
+                         distribution=distribution,
+                         data=data,
+                         labels=labels,
+                         origin=origin,
+                         units=units,
+                         axes=axes,
+                         nav_indexes=nav_indexes,
+                         errors=errors,
+                         **kwargs)
 
 
 class DataToExport(DataLowLevel):
@@ -3041,7 +3124,17 @@ class DataToExport(DataLowLevel):
         return self.data.pop(index)
 
     def remove(self, dwa: DataWithAxes):
-        return self.pop(self.data.index(dwa))
+        """ Use the DataWithAxes object comparison __eq__ to retrieve the elt to remove
+
+        If strict is True will also check for the real type and name of the object
+
+        Parameters
+        ----------
+        """
+        for dwa_tmp in self:
+            if dwa_tmp == dwa and dwa_tmp.name == dwa.name:
+                return dwa_tmp
+        raise ValueError()
 
     @property
     def data(self) -> List[DataWithAxes]:

{pymodaq_data-5.0.5 → pymodaq_data-5.0.7}/src/pymodaq_data/plotting/plotter/plotter.py

@@ -54,6 +54,10 @@ class PlotterBase(metaclass=ABCMeta):
 class PlotterFactory(ObjectFactory):
     """Factory class registering and storing interactive plotter"""
 
+    def __init__(self):
+        if PlotterFactory.__name__ not in PlotterFactory._builders:
+            PlotterFactory._builders[PlotterFactory.__name__] = {}
+
     @classmethod
     def register(cls) -> Callable:
         """ To be used as a decorator