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

pymodaq/utils/parameter/__init__.py

@@ -1,13 +1,10 @@
-from qtpy import QtWidgets
+from pymodaq_gui.parameter import Parameter, ParameterTree, utils, ioxml, pymodaq_ptypes
+from sys import modules as sysmodules
+from pymodaq_utils.warnings import deprecation_msg
 
-from pyqtgraph.parametertree import parameterTypes, Parameter, ParameterTree
-from . import pymodaq_ptypes
 
+sysmodules["pymodaq.utils.parameter.pymodaq_ptypes"] = pymodaq_ptypes
 
-class ParameterTree(ParameterTree):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
 
-        self.header().setVisible(True)
-        self.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Interactive)
-        self.header().setMinimumSectionSize(150)
+deprecation_msg('Importing Parameter stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_gui package')

pymodaq/utils/parameter/utils.py

@@ -1,330 +1,6 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING, List
-import numpy as np
-from collections import OrderedDict
-from dataclasses import dataclass
-from pymodaq.utils.daq_utils import find_keys_from_val
+from pymodaq_gui.parameter.utils import *
 
-if TYPE_CHECKING:
-    from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.warnings import deprecation_msg
 
-
-class ParameterWithPath:
-    """ holds together a Parameter object and its full path
-
-    To be used when communicating between TCPIP to reconstruct properly the Parameter
-
-    Parameters
-    ----------
-    parameter: Parameter
-        a Parameter object
-    path: full path of the parameter, if None it is constructed from the parameter parents
-    """
-    def __init__(self, parameter: Parameter, path: List[str] = None):
-        self._parameter = parameter
-        if path is None:
-            path = get_param_path(parameter)
-        self._path = path
-
-    @property
-    def parameter(self) -> Parameter:
-        return self._parameter
-
-    @property
-    def path(self) -> List[str]:
-        return self._path
-
-
-def get_widget_from_tree(parameter_tree, widget_instance):
-    widgets = []
-    for item in parameter_tree.listAllItems():
-        if hasattr(item, 'widget'):
-            if item.widget.__class__.__name__ == widget_instance.__name__:
-                widgets.append(item.widget)
-    return widgets
-
-
-def get_param_path(param: Parameter) -> List[str]:
-    """ Get the parameter path from its highest parent down to the given parameter including its
-    identifier (name)
-
-    Parameters
-    ----------
-    param: Parameter
-        The parameter object
-
-    Returns
-    -------
-    List[str]: the path as a list of parameter identifiers
-    """
-    path = [param.name()]
-    while param.parent() is not None:
-        path.append(param.parent().name())
-        param = param.parent()
-    return path[::-1]
-
-
-def getOpts(param:Parameter,) -> OrderedDict:
-    """Return an OrderedDict with tree structures of all opts for all children of this parameter
-        Parameters
-        ----------
-        param: Parameter
-        Returns
-        -------
-        OrderedDict
-    """
-    vals = OrderedDict()    
-    for ch in param:      
-        vals[ch.name()] = (ch.opts, getOpts(ch))
-    return vals
-
-def getStruct(param:Parameter,) -> OrderedDict:
-    """Return an OrderedDict with tree structures of all children of this parameter
-        Parameters
-        ----------
-        param: Parameter
-        Returns
-        -------
-        OrderedDict    
-    """
-    vals = OrderedDict()
-    for ch in param:      
-        vals[ch.name()] = (None, getStruct(ch))
-    return vals 
-
-def getValues(param:Parameter,) -> OrderedDict:
-    """Return an OrderedDict with tree structures of all values for all children of this parameter
-        Parameters
-        ----------
-        param: Parameter
-        Returns
-        -------
-        OrderedDict    
-    """    
-    return param.getValues()
-
-def compareParameters(param1:Parameter,param2:Parameter,opts:list=[])-> bool:  
-    """Compare the structure and the opts of two parameters with their children, return True if structure and all opts are identical
-        Parameters
-        ----------
-        param1: Parameter
-        param2: Parameter   
-        
-        Returns
-        -------
-        Bool    
-    """    
-    return getOpts(param1) == getOpts(param2) 
-    
-def compareStructureParameter(param1:Parameter,param2:Parameter,)-> bool:  
-    """Compare the structure of two parameters with their children, return True if structure is identical
-        Parameters
-        ----------
-        param1: Parameter
-        param2: Parameter   
-        
-        Returns
-        -------
-        Bool    
-    """    
-    return getStruct(param1) == getStruct(param2)
-
-def compareValuesParameter(param1:Parameter,param2:Parameter,)-> bool:  
-    """Compare the structure and the values of two parameters with their children, return True if structures and values are identical
-        Parameters
-        ----------
-        param1: Parameter
-        param2: Parameter   
-        
-        Returns
-        -------
-        Bool    
-    """    
-    return getValues(param1) == getValues(param2)    
-
-def iter_children(param, childlist=[]):
-    """Get a list of parameters name under a given Parameter
-        | Returns all childrens names.
-
-        =============== ================================= ====================================
-        **Parameters**   **Type**                           **Description**
-        *param*          instance of pyqtgraph parameter    the root node to be coursed
-        *childlist*      list                               the child list recetion structure
-        =============== ================================= ====================================
-
-        Returns
-        -------
-        childlist : parameter list
-            The list of the children from the given node.
-    """
-    for child in param.children():
-        childlist.append(child.name())
-        if child.hasChildren():
-        # if 'group' in child.type():
-            childlist.extend(iter_children(child, []))
-    return childlist
-
-
-def iter_children_params(param, childlist=[]):
-    """Get a list of parameters under a given Parameter
-
-    """
-    for child in param.children():
-        childlist.append(child)
-        if child.hasChildren():
-            childlist.extend(iter_children_params(child, []))
-    return childlist
-
-
-def get_param_from_name(parent, name) -> Parameter:
-    """Get Parameter under parent whose name is name
-
-    Parameters
-    ----------
-    parent: Parameter
-    name: str
-
-    Returns
-    -------
-    Parameter
-    """
-    for child in parent.children():
-        if child.name() == name:
-            return child
-        if child.hasChildren():
-            ch = get_param_from_name(child, name)
-            if ch is not None:
-                return ch
-
-
-def is_name_in_dict(dict_tmp, name):
-    if 'name' in dict_tmp:
-        if dict_tmp['name'] == name:
-            return True
-    return False
-
-
-def get_param_dict_from_name(parent_list, name, pop=False):
-    """Get dict under parent whose name is name. The parent_list structure is the one used to init a Parameter object
-
-    Parameters
-    ----------
-    parent_list: (list of dicts) as defined to init Parameter object
-    name: (str) value to find for the key: name
-    pop: (bool) if True remove the matched dict from parent
-
-    Returns
-    -------
-    dict the matched dict
-    """
-    for index, parent_dict in enumerate(parent_list):
-        if is_name_in_dict(parent_dict, name):
-            if pop:
-                return parent_list.pop(index)
-            else:
-                return parent_dict
-
-        elif 'children' in parent_dict:
-            ch = get_param_dict_from_name(parent_dict['children'], name, pop)
-            if ch is not None:
-                return ch
-
-
-if __name__ == '__main__':              # pragma: no cover
-    parent = [
-        {'title': 'Spectro Settings:', 'name': 'spectro_settings', 'type': 'group', 'expanded': True,
-            'children': [
-                {'title': 'Home Wavelength (nm):', 'name': 'spectro_wl_home', 'type': 'float', 'value': 600, 'min': 0,
-                 'readonly': False},
-                {'title': 'Grating Settings:', 'name': 'grating_settings', 'type': 'group', 'expanded': True,
-                    'children': [
-                        {'title': 'Grating:', 'name': 'grating', 'type': 'list'},
-                        {'title': 'Lines (/mm):', 'name': 'lines', 'type': 'int', 'readonly': True},
-                        {'title': 'Blaze WL (nm):', 'name': 'blaze', 'type': 'str', 'readonly': True},
-                    ]},
-            ]
-         },
-    ]
-
-    d = get_param_dict_from_name(parent, 'lines')
-
-    d['readonly'] = False
-    print(parent[0]['children'][1]['children'])
-
-
-def set_param_from_param(param_old, param_new):
-    """
-        Walk through parameters children and set values using new parameter values.
-    """
-    for child_old in param_old.children():
-        # try:
-        path = param_old.childPath(child_old)
-        child_new = param_new.child(*path)
-        param_type = child_old.type()
-
-        if 'group' not in param_type:  # covers 'group', custom 'groupmove'...
-            # try:
-            if 'list' in param_type:  # check if the value is in the limits of the old params
-                # (limits are usually set at initialization) but carefull as such paramater limits can be a list or a
-                # dict object
-                if isinstance(child_old.opts['limits'], list):
-                    if child_new.value() not in child_old.opts['limits']:
-                        new_limits = child_old.opts['limits'].copy()
-                        new_limits.append(child_new.value())
-                        child_old.setLimits(new_limits)
-                        
-                elif isinstance(child_old.opts['limits'], dict):
-                    if child_new.value() not in child_old.opts['limits'].values():
-                        child_new_key = find_keys_from_val(child_new.opts['limits'], child_new.value())[0]
-                        new_limits = child_old.opts['limits'].copy()
-                        new_limits.update({child_new_key: child_new.value()})
-                        child_old.setLimits(new_limits)
-
-                child_old.setValue(child_new.value())
-            elif 'str' in param_type or 'browsepath' in param_type or 'text' in param_type:
-                if child_new.value() != "":  # to make sure one doesnt overwrite something
-                    child_old.setValue(child_new.value())
-            else:
-                child_old.setValue(child_new.value())
-            # except Exception as e:
-            #    print(str(e))
-        else:
-            set_param_from_param(child_old, child_new)
-        # except Exception as e:
-        #    print(str(e))
-
-
-def scroll_log(scroll_val, min_val, max_val):
-    """
-    Convert a scroll value [0-100] to a log scale between min_val and max_val
-    Parameters
-    ----------
-    scroll
-    min_val
-    max_val
-    Returns
-    -------
-
-    """
-    assert scroll_val >= 0
-    assert scroll_val <= 100
-    value = scroll_val * (np.log10(max_val) - np.log10(min_val)) / 100 + np.log10(min_val)
-    return 10 ** value
-
-
-def scroll_linear(scroll_val, min_val, max_val):
-    """
-    Convert a scroll value [0-100] to a linear scale between min_val and max_val
-    Parameters
-    ----------
-    scroll
-    min_val
-    max_val
-    Returns
-    -------
-
-    """
-    assert scroll_val >= 0
-    assert scroll_val <= 100
-    value = scroll_val * (max_val - min_val) / 100 + min_val
-    return value
+deprecation_msg('Importing Parameter stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_gui.parameter module')

pymodaq/utils/scanner/scan_config.py

@@ -6,7 +6,7 @@ Created the 19/11/2023
 """
 
 from pathlib import Path
-from pymodaq.utils.config import BaseConfig, getitem_recursive
+from pymodaq_utils.config import BaseConfig
 
 
 class ScanConfig(BaseConfig):

pymodaq/utils/scanner/scan_factory.py

@@ -13,19 +13,23 @@ from typing import Callable, Union, List, Tuple, TYPE_CHECKING
 import numpy as np
 from qtpy import QtWidgets
 
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
-from pymodaq.utils.parameter.utils import get_param_path, iter_children_params
-from pymodaq.utils.factory import ObjectFactory
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.data import Axis, DataDistribution
-from pymodaq.utils.abstract import abstract_attribute
-from pymodaq.utils import math_utils as mutils
-from pymodaq.utils import config as configmod
+from pymodaq_utils.factory import ObjectFactory
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.abstract import abstract_attribute
+from pymodaq_utils import math_utils as mutils
+from pymodaq_utils import config as configmod
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter
+
+from pymodaq_data.data import Axis, DataDistribution
+
 from pymodaq.utils.scanner.scan_config import ScanConfig
+from pymodaq_gui.config import ConfigSaverLoader
+
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move
-    from pymodaq.utils.plotting.scan_selector import Selector
+    from pymodaq.utils.scanner.scan_selector import Selector
 
 
 logger = set_logger(get_module_name(__file__))
@@ -84,9 +88,9 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
         self.config = ScanConfig()
         base_path = [act.title for act in actuators] + [self.scan_type, self.scan_subtype]
 
-        self.config_saver_loader = configmod.ConfigSaverLoader(self.settings,
-                                                               self.config,
-                                                               base_path)
+        self.config_saver_loader = ConfigSaverLoader(self.settings,
+                                                     self.config,
+                                                     base_path)
 
         self.actuators: List[DAQ_Move] = actuators
 

pymodaq/utils/{plotting → scanner}/scan_selector.py

@@ -1,29 +1,28 @@
+from abc import ABC, abstractmethod
+from collections import OrderedDict
 import importlib
 import time
-from typing import Callable, Union, List, Tuple, TYPE_CHECKING
-from abc import abstractproperty
+import sys
+from typing import List, Dict
 
 import numpy as np
 from qtpy import QtWidgets, QtCore
 from qtpy.QtCore import QObject, Slot, QThread, Signal
-import sys
-from typing import List, Dict
-from collections import OrderedDict
+
 from pyqtgraph import ROI, RectROI, PolyLineROI, Point, LinearRegionItem
-from abc import ABC, abstractmethod
-from pymodaq.utils.parameter import Parameter, ParameterTree
-from pymodaq.utils.managers.parameter_manager import ParameterManager
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.gui_utils import DockArea, Dock
-from pymodaq.utils.plotting.utils.plot_utils import QVector
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils import gui_utils as gutils
-from pymodaq.utils.enums import BaseEnum, enum_checker
-from pymodaq.utils.parameter.pymodaq_ptypes import TableViewCustom
-from pymodaq.utils.parameter import utils as putils
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase
-from pymodaq.utils.factory import ObjectFactory
-from pymodaq.utils.data import DataDim
+
+from pymodaq_utils.factory import ObjectFactory
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import utils
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_gui import utils as gutils
+from pymodaq_gui.utils import DockArea, Dock
+from pymodaq_gui.plotting.utils.plot_utils import QVector
+from pymodaq_gui.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerBase
+
 
 logger = set_logger(get_module_name(__file__))
 
@@ -371,7 +370,7 @@ class ScanSelector(ParameterManager, QObject):
 
     def update_selector_type(self):
         self.remove_selector()
-        mod = importlib.import_module('.scan_selector', 'pymodaq.utils.plotting')
+        mod = importlib.import_module('.scan_selector', 'pymodaq.utils.scanner')
         self.selector = selector_factory.create(self.settings['scan_options', 'selector_type'])
 
         if self.selector_source is not None and self.selector is not None:

pymodaq/utils/scanner/scanner.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 from typing import Tuple, List, TYPE_CHECKING
 from collections import OrderedDict
 
+from qtpy.QtCore import QObject, Signal
+from qtpy import QtWidgets
 
-from qtpy import QtWidgets, QtCore
-from qtpy.QtCore import QObject, Signal, Slot
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+import pymodaq_utils.utils as utils
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.config import Config
 from pymodaq.utils.scanner.scan_factory import ScannerFactory, ScannerBase
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
-import pymodaq.utils.daq_utils as utils
 from pymodaq.utils.scanner.utils import ScanInfo
-from pymodaq.utils.plotting.scan_selector import Selector
+from pymodaq.utils.scanner.scan_selector import Selector
 from pymodaq.utils.data import DataToExport, DataActuator
 
 if TYPE_CHECKING:
@@ -45,7 +46,8 @@ class Scanner(QObject, ParameterManager):
     params = [
         {'title': 'Calculate positions:', 'name': 'calculate_positions', 'type': 'action'},
         {'title': 'N steps:', 'name': 'n_steps', 'type': 'int', 'value': 0, 'readonly': True},
-        {'title': 'Scan type:', 'name': 'scan_type', 'type': 'list', 'limits': scanner_factory.scan_types()},
+        {'title': 'Scan type:', 'name': 'scan_type', 'type': 'list',
+         'limits': scanner_factory.scan_types()},
         {'title': 'Scan subtype:', 'name': 'scan_sub_type', 'type': 'list',
          'limits': scanner_factory.scan_sub_types(scanner_factory.scan_types()[0])},
     ]

pymodaq/utils/scanner/scanners/_1d_scanners.py

@@ -7,11 +7,14 @@ Created the 05/12/2022
 from typing import List, Tuple, Any, TYPE_CHECKING
 import re
 import numpy as np
-from pymodaq.utils.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.utils.plotting.scan_selector import Selector
+
+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.data import Axis, DataDistribution
+
+from pymodaq.utils.scanner.scan_selector import Selector
 
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
 

pymodaq/utils/scanner/scanners/_2d_scanners.py

@@ -7,11 +7,11 @@ Created the 05/12/2022
 from typing import List, Tuple, TYPE_CHECKING
 
 import numpy as np
-from pymodaq.utils.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.utils.plotting.scan_selector import Selector
+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.utils.scanner.scan_selector import Selector
 
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
 

pymodaq/utils/scanner/scanners/sequential.py

@@ -9,15 +9,15 @@ from typing import List, Tuple, TYPE_CHECKING
 import numpy as np
 
 from qtpy import QtCore, QtWidgets
-from pymodaq.utils.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.utils import gui_utils as gutils
+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_gui import utils as gutils
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
-from pymodaq.utils.parameter import utils as putils
-from pymodaq.utils.parameter.pymodaq_ptypes import TableViewCustom
-from pymodaq.utils.plotting.scan_selector import Selector
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq.utils.scanner.scan_selector import Selector
 
 logger = set_logger(get_module_name(__file__))
 config = configmod.Config()

pymodaq/utils/scanner/scanners/tabular.py

@@ -9,16 +9,16 @@ from typing import List, Tuple, TYPE_CHECKING
 import numpy as np
 
 from qtpy import QtCore, QtWidgets
-from pymodaq.utils.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.utils import gui_utils as gutils
+from pymodaq_data.data import Axis, DataDistribution
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_utils import config as configmod
+from pymodaq_gui import utils as gutils
 from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
-from pymodaq.utils.parameter import utils as putils
-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
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq.utils.scanner.scan_selector import Selector
+from pymodaq_gui.plotting.utils.plot_utils import Point, get_sub_segmented_positions
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move

pymodaq/utils/scanner/utils.py

@@ -8,11 +8,13 @@ from importlib import import_module
 from pathlib import Path
 
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.config import Config
-from pymodaq.utils.daq_utils import get_entrypoints
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+from pymodaq_utils.utils import get_entrypoints
+from pymodaq_utils.enums import BaseEnum
+
 from pymodaq.utils.scanner.scan_factory import ScannerFactory
-from pymodaq.utils.enums import BaseEnum
+
 
 logger = set_logger(get_module_name(__file__))
 config = Config()

pymodaq/utils/svg/svg_viewer2D.py

@@ -8,10 +8,9 @@ import sys
 
 import numpy as np
 
-from qtpy import QtWidgets, QtCore, QtSvg
-from pyqtgraph.widgets.GraphicsView import GraphicsView
-from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
-from pymodaq.utils.data import Axis, DataToExport, DataFromRoi, DataFromPlugins, DataRaw
+from qtpy import QtWidgets
+from pymodaq_gui.plotting.data_viewers.viewer2D import Viewer2D
+from pymodaq.utils.data import Axis, DataFromRoi, DataFromPlugins
 
 
 def main():