pymodaq 5.0.18__py3-none-any.whl → 5.1.0__py3-none-any.whl

pymodaq/utils/scanner/scanners/_2d_scanners.py

@@ -32,8 +32,8 @@ class Scan2DBase(ScannerBase):
                 ]
     axes = ('axis1','axis2')    
     n_axes = 2
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
         self.axes_unique = []
 
         
@@ -64,8 +64,19 @@ class Scan2DLinear(Scan2DBase):
     scan_type = 'Scan2D'
     scan_subtype = 'Linear'
 
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_units(self):
+        """ Update settings units depending on the scanner type and the display_units boolean"""
+        if len(self.actuators) > 0:
+            for child in self.settings.child('axis1').children():
+                child.setOpts(
+                    suffix='' if not self.display_units else self.actuators[0].units)
+        if len(self.actuators) > 1:
+            for child in self.settings.child('axis2').children():
+                child.setOpts(
+                    suffix='' if not self.display_units else self.actuators[1].units)
 
     def get_pos(self):
         starts = np.array([self.settings[ax, f'start_{ax}'] for ax in self.axes])
@@ -133,8 +144,8 @@ class Scan2DLinear(Scan2DBase):
 class Scan2DLinearBF(Scan2DLinear):
     scan_subtype = 'LinearBackForce'
 
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
 
     def set_scan(self):
         starts, stops, steps = self.get_pos()
@@ -163,8 +174,8 @@ class Scan2DLinearBF(Scan2DLinear):
 class Scan2DRandom(Scan2DLinear):
     scan_subtype = 'Random'
 
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
 
     def set_scan(self):
         super().set_scan()
@@ -197,8 +208,8 @@ class Scan2DSpiral(Scan2DLinear):
                ]},
               ]  
    
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
 
     def set_settings_titles(self):
         if len(self.actuators) == 2:
@@ -286,61 +297,3 @@ class Scan2DSpiral(Scan2DLinear):
                 self.settings.child(ax, f'rmax_{ax}').setValue(
                     (coordinates[0, i] - coordinates[1, i]) / 2)
 
-
-try:
-    import adaptive
-
-    @ScannerFactory.register()
-    class Scan2DAdaptive(Scan2DLinear):
-        scan_subtype = 'Adaptive'
-
-        params = [
-            {'title': 'Loss type', 'name': 'scan_loss', 'type': 'list',
-             'limits': ['default', 'curvature', 'uniform'],
-             'tip': 'Type of loss used by the algo. to determine next points'},
-
-            {'title': 'Ax1:', 'name': 'axis1', 'type': 'group',
-               'children':[
-              {'title': 'Start Ax1:', 'name': 'start_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'start1')},
-              {'title': 'Stop Ax1:', 'name': 'stop_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'stop1')},              
-              {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'step1')},
-              ]}, 
-              {'title': 'Ax2:', 'name': 'axis2', 'type': 'group',
-               'children':[
-              {'title': 'Start Ax2:', 'name': 'start_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'start2')},
-              {'title': 'Stop Ax2:', 'name': 'stop_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'stop2')},              
-              {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
-               'value': config('scan', 'scan2D', 'linear', 'step2')},              
-               ]},
-            ]
-        distribution = DataDistribution['spread']
-
-        def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-            super().__init__(actuators=actuators)
-
-        def set_scan(self):
-
-            self.axes_unique = [np.array([]), np.array([])]
-            self.axes_indexes = np.array([], dtype=int)
-            self.positions = np.zeros((0, 2))
-
-        def evaluate_steps(self) -> int:
-            return 1
-
-        def get_nav_axes(self) -> List[Axis]:
-            return [Axis(label=f'{act.mod_name} axis',
-                         units=f'{act.units}',
-                         data=self.positions[:, ind],
-                         index=ind) for ind, act in enumerate(self.actuators)]
-
-        def get_scan_shape(self) -> Tuple[int]:
-            return ()  # unknown shape
-
-except ModuleNotFoundError:
-    logger.info('adaptive module is not present, no adaptive scan possible')
-

pymodaq/utils/scanner/scanners/sequential.py

@@ -4,7 +4,7 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple, TYPE_CHECKING
+from typing import List, Tuple, TYPE_CHECKING, Iterable
 
 import numpy as np
 
@@ -13,6 +13,8 @@ from pymodaq_data.data import Axis, DataDistribution
 from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils import math_utils as mutils
 from pymodaq_utils import config as configmod
+from pymodaq_data import Q_
+
 from pymodaq_gui import utils as gutils
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
 from pymodaq_gui.parameter import utils as putils
@@ -36,7 +38,7 @@ class TableModelSequential(gutils.TableModel):
         editable = [False, True, True, True]
         if 'editable' in kwargs:
             editable = kwargs.pop('editable')
-        super().__init__(data, header, editable=editable, **kwargs)
+        super().__init__(data, header, editable=editable, cast=str, **kwargs)
 
     def __repr__(self):
         return f'{self.__class__.__name__} from module {self.__class__.__module__}'
@@ -54,9 +56,10 @@ class TableModelSequential(gutils.TableModel):
         -------
         bool: True is the new value is fine (change some other values if needed) otherwise False
         """
-        start = self.data(self.index(row, 1), QtCore.Qt.DisplayRole)
-        stop = self.data(self.index(row, 2), QtCore.Qt.DisplayRole)
-        step = self.data(self.index(row, 3), QtCore.Qt.DisplayRole)
+        start = Q_(self.data(self.index(row, 1), QtCore.Qt.DisplayRole))
+        stop = Q_(self.data(self.index(row, 2), QtCore.Qt.DisplayRole))
+        step = Q_(self.data(self.index(row, 3), QtCore.Qt.DisplayRole))
+        value = Q_(value)
         isstep = False
         if col == 1:  # the start
             start = value
@@ -65,14 +68,16 @@ class TableModelSequential(gutils.TableModel):
         elif col == 3:  # the step
             isstep = True
             step = value
-
-        if np.abs(step) < 1e-12 or start == stop:
+        try:
+            if np.abs(step).magnitude < 1e-12 or start == stop:
+                return False
+            if np.sign(stop - start) != np.sign(step):
+                if isstep:
+                    self._data[row][2] = str(-stop)
+                else:
+                    self._data[row][3] = str(-step)
+        except (TypeError, ValueError):
             return False
-        if np.sign(stop - start) != np.sign(step):
-            if isstep:
-                self._data[row][2] = -stop
-            else:
-                self._data[row][3] = -step
         return True
 
 
@@ -88,13 +93,17 @@ class SequentialScanner(ScannerBase):
     distribution = DataDistribution['uniform']
     n_axes = 1
 
-    def __init__(self, actuators: List['DAQ_Move']):
+    def __init__(self, actuators: List['DAQ_Move'], display_units=True, **_ignored):
 
         self.table_model: TableModelSequential = None
         self.table_view: TableViewCustom = None
-        super().__init__(actuators)
+        super().__init__(actuators, display_units=display_units)
+        self.delegates: Iterable[gutils.SpinBoxDelegate] = []
         self.update_model()
 
+    def set_units(self):
+        pass
+
     @property
     def actuators(self):
         return self._actuators
@@ -116,9 +125,15 @@ class SequentialScanner(ScannerBase):
                         ind_row = names.index(act.title)
                         init_data.append(self.table_model.get_data_all()[ind_row])
                     else:
-                        init_data.append([act.title, 0., 1., 0.1])
+                        if self.display_units:
+                            init_data = [[act.title, f'0. {act.units}', f'1. {act.units}', f'0.1 {act.units}'] for act in self._actuators]
+                        else:
+                            init_data.append([act.title, '0.', '1.', '0.1'])
             else:
-                init_data = [[act.title, 0., 1., 0.1] for act in self._actuators]
+                if self.display_units:
+                    init_data = [[act.title, f'0. {act.units}', f'1. {act.units}', f'0.1 {act.units}'] for act in self._actuators]
+                else:
+                    init_data = [[act.title, '0.', '1.', '0.1'] for act in self._actuators]
         self.table_model = TableModelSequential(init_data, )
         self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
         self.settings.child('seq_table').setValue(self.table_model)
@@ -126,19 +141,19 @@ class SequentialScanner(ScannerBase):
         self.update_table_view()
 
     def get_pos(self):
-        starts = np.array([self.table_model.get_data(ind, 1)
-                           for ind in range(self.table_model.rowCount(None))])
-        stops = np.array([self.table_model.get_data(ind, 2)
-                          for ind in range(self.table_model.rowCount(None))])
-        steps = np.array([self.table_model.get_data(ind, 3)
-                          for ind in range(self.table_model.rowCount(None))])
+        starts = [Q_(self.table_model.get_data(ind, 1))
+                           for ind in range(self.table_model.rowCount(None))]
+        stops = [Q_(self.table_model.get_data(ind, 2))
+                          for ind in range(self.table_model.rowCount(None))]
+        steps = [Q_(self.table_model.get_data(ind, 3))
+                          for ind in range(self.table_model.rowCount(None))]
         return starts, stops, steps
 
     def evaluate_steps(self) -> int:
         starts, stops, steps = self.get_pos()
         n_steps = 1
-        for ind in range(starts.size):
-            n_steps *= np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1
+        for ind in range(len(starts)):
+            n_steps *= (np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1).magnitude
         return int(n_steps)
 
     @staticmethod
@@ -152,13 +167,17 @@ class SequentialScanner(ScannerBase):
         return state
 
     def update_table_view(self):
-        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
+        #self.table_view.horizontalHeader().setStretchLastSection(True)
         self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
-        styledItemDelegate = QtWidgets.QStyledItemDelegate()
-        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
-        self.table_view.setItemDelegate(styledItemDelegate)
+        self.delegates = []  # ItemDelegates should have parents and be instance attribute to work with setItemDelegateForColumn
+        for ind_actuator, actuator in enumerate(self.actuators):
+
+            self.delegates.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForRow(
+                ind_actuator, self.delegates[-1])
 
         self.table_view.setDragEnabled(True)
         self.table_view.setDropIndicatorShown(True)
@@ -186,8 +205,8 @@ class SequentialScanner(ScannerBase):
                 state = self.pos_above_stops(positions, steps, stops)
                 if not np.any(np.array(state)):
                     all_positions.append(positions.copy())
-
-        self.get_info_from_positions(np.array(all_positions))
+        all_positions = np.array([[elt.magnitude for elt in positions] for positions in all_positions])
+        self.get_info_from_positions(all_positions)
 
     def get_nav_axes(self) -> List[Axis]:
         return [Axis(label=f'{act.title}', units=act.units, data=self.axes_unique[ind], index=ind)

pymodaq/utils/scanner/scanners/tabular.py

@@ -4,12 +4,14 @@ Created the 05/12/2022
 
 @author: Sebastien Weber
 """
-from typing import List, Tuple, TYPE_CHECKING
+from typing import List, Tuple, TYPE_CHECKING, Iterable
 
 import numpy as np
 
 from qtpy import QtCore, QtWidgets
 from pymodaq_data.data import Axis, DataDistribution
+from pymodaq_data import Q_
+from pymodaq_gui.utils import SpinBoxDelegate
 from pymodaq_utils.logger import set_logger, get_module_name
 
 from pymodaq_utils import config as configmod
@@ -37,19 +39,18 @@ class TableModelTabular(gutils.TableModel):
                 kwargs.pop('header')
             else:
                 raise Exception('Invalid header')
-
         header = [name for name in axes_name]
         editable = [True for name in axes_name]
-        super().__init__(data, header, editable=editable, **kwargs)
+        super().__init__(data, header, editable=editable, cast=str, **kwargs)
 
     def __len__(self):
         return len(self._data)
 
     def add_data(self, row, data=None):
         if data is not None:
-            self.insert_data(row, [float(d) for d in data])
+            self.insert_data(row, [f'{d}' for d in data])
         else:
-            self.insert_data(row, [0. for name in self.header])
+            self.insert_data(row, ['0.' for name in self.header])
 
     def remove_data(self, row):
         self.remove_row(row)
@@ -106,10 +107,14 @@ class TabularScanner(ScannerBase):
               ]
     distribution = DataDistribution['spread']
 
-    def __init__(self, actuators: List['DAQ_Move']):
+    def __init__(self, actuators: List['DAQ_Move'], display_units=True, **kwargs):
         self.table_model: TableModelTabular = None
         self.table_view: TableViewCustom = None
-        super().__init__(actuators=actuators)
+        super().__init__(actuators=actuators, display_units=display_units)
+        self.delegates: Iterable[SpinBoxDelegate] = []
+
+    def set_units(self):
+        pass
 
     @property
     def actuators(self):
@@ -124,7 +129,10 @@ class TabularScanner(ScannerBase):
 
     def update_model(self, init_data=None):
         if init_data is None:
-            init_data = [[0. for _ in self._actuators]]
+            if self.display_units:
+                init_data = [[f'0. {act.units}' for act in self._actuators]]
+            else:
+                init_data = [['0.' for _ in self._actuators]]
 
         self.table_model = TableModelTabular(init_data, [act.title for act in self._actuators])
         self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
@@ -133,13 +141,17 @@ class TabularScanner(ScannerBase):
         self.update_table_view()
 
     def update_table_view(self):
-        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
+        # self.table_view.horizontalHeader().setStretchLastSection(True)
         self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
-        styledItemDelegate = QtWidgets.QStyledItemDelegate()
-        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
-        self.table_view.setItemDelegate(styledItemDelegate)
+        self.delegates = []  # ItemDelegates should have parents and be instance attribute to work with setItemDelegateForColumn
+        for ind_actuator, actuator in enumerate(self.actuators):
+
+            self.delegates.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForColumn(
+                ind_actuator, self.delegates[-1])
 
         self.table_view.setDragEnabled(True)
         self.table_view.setDropIndicatorShown(True)
@@ -158,7 +170,7 @@ class TabularScanner(ScannerBase):
         return len(self.table_model)
 
     def set_scan(self):
-        positions = np.array(self.table_model.get_data_all())
+        positions = np.array([[Q_(elt).magnitude for elt in line] for line in self.table_model.get_data_all()])
         self.get_info_from_positions(positions)
 
     def update_tabular_positions(self, positions: np.ndarray = None):
@@ -223,12 +235,12 @@ class TabularScannerSubSegmented(TabularScanner):
                'menu': True},
               ] + TabularScanner.params
 
-    def __init__(self, actuators: List['DAQ_Move']):
+    def __init__(self, actuators: List['DAQ_Move'], display_units=True):
         self.table_model: TableModelTabularReadOnly = None
         self.table_view: TableViewCustom = None
         self.table_model_points: TableModelTabular = None
         self.table_view_points: TableViewCustom = None
-        super().__init__(actuators=actuators)
+        super().__init__(actuators=actuators, display_units=display_units)
 
     @property
     def actuators(self):
@@ -242,7 +254,7 @@ class TabularScannerSubSegmented(TabularScanner):
 
     def update_model(self, init_data=None):
         if init_data is None:
-            init_data = [[0. for _ in self._actuators]]
+            init_data = [['0.' for _ in self._actuators]]
 
         self.table_model = TableModelTabularReadOnly(init_data, [act.title for act in self._actuators])
         self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[1]
@@ -252,7 +264,7 @@ class TabularScannerSubSegmented(TabularScanner):
 
     def update_model_points(self, init_data=None):
         if init_data is None:
-            init_data = [[0. for _ in self._actuators]]
+            init_data = [['0.' for _ in self._actuators]]
 
         self.table_model_points = TableModelTabular(init_data, [act.title for act in self._actuators])
         self.table_view_points = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
@@ -260,20 +272,26 @@ class TabularScannerSubSegmented(TabularScanner):
         self.update_table_view_points()
 
     def update_table_view(self):
-        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
         self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
-        # self.table_view.setEnabled(False)
+        self.delegates = []
+        for ind_actuator, actuator in enumerate(self.actuators):
+            self.delegates.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForColumn(
+                ind_actuator, self.delegates[-1])
 
     def update_table_view_points(self):
-        self.table_view_points.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self.table_view_points.horizontalHeader().setStretchLastSection(True)
+        self.table_view_points.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
         self.table_view_points.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view_points.setSelectionMode(QtWidgets.QTableView.SingleSelection)
-        styledItemDelegate = QtWidgets.QStyledItemDelegate()
-        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
-        self.table_view.setItemDelegate(styledItemDelegate)
+        self.delegates_points = []
+        for ind_actuator, actuator in enumerate(self.actuators):
+            self.delegates_points.append(gutils.SpinBoxDelegate(self.table_view,
+                                                         units=actuator.units if self.display_units else None))
+            self.table_view.setItemDelegateForColumn(
+                ind_actuator, self.delegates_points[-1])
 
         self.table_view_points.setDragEnabled(True)
         self.table_view_points.setDropIndicatorShown(True)
@@ -291,9 +309,8 @@ class TabularScannerSubSegmented(TabularScanner):
     def set_scan(self):
         points = [Point(coordinates) for coordinates in self.table_model_points.get_data_all()]
         positions = get_sub_segmented_positions(self.settings['tabular_step'], points)
-
         self.table_model.set_data_all(positions)
-        positions = np.array(self.table_model.get_data_all())
+        positions = np.array([[Q_(elt).magnitude for elt in line] for line in self.table_model.get_data_all()])
         self.get_info_from_positions(positions)
 
     def update_from_scan_selector(self, scan_selector: Selector):

{pymodaq-5.0.18.dist-info → pymodaq-5.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymodaq
-Version: 5.0.18
+Version: 5.1.0
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -43,18 +43,19 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.8
-Requires-Dist: bayesian-optimization<2.0.0
+Requires-Dist: adaptive
+Requires-Dist: bayesian-optimization>=2.0
 Requires-Dist: easydict
 Requires-Dist: multipledispatch
 Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: pyleco<=0.4.2,>0.3; python_version >= '3.8'
-Requires-Dist: pymodaq-data>=5.0.18
-Requires-Dist: pymodaq-gui<5.0.23,>=5.0.17
+Requires-Dist: pyleco>0.3; python_version >= '3.8'
+Requires-Dist: pymodaq-data>=5.0.21
+Requires-Dist: pymodaq-gui>=5.0.26
 Requires-Dist: pymodaq-plugin-manager>=0.0.17
 Requires-Dist: pymodaq-plugins-mock>=5.0.5
-Requires-Dist: pymodaq-utils<1.0.0,>=0.0.14
+Requires-Dist: pymodaq-utils>=1.0.10
 Requires-Dist: pyqtgraph>=0.12
 Requires-Dist: python-dateutil
 Requires-Dist: qtconsole