pymodaq 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

pymodaq/post_treatment/load_and_plot.py

@@ -6,15 +6,20 @@ Created the 22/01/2023
 """
 import os
 import sys
-from typing import List, Union, Callable, Iterable
+from typing import List, Union, Callable, Iterable, Dict
 
 from qtpy import QtWidgets, QtCore
 
 from pymodaq.utils.data import DataToExport, DataFromPlugins, DataDim, enum_checker
 from pymodaq.utils.h5modules.data_saving import DataLoader
 from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase, ViewersEnum, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers import ViewersEnum, Viewer1D, Viewer2D, ViewerND
 from pymodaq.utils.gui_utils import Dock, DockArea
+from pymodaq.utils.logger import set_logger, get_module_name
+
+
+logger = set_logger(get_module_name(__file__))
 
 
 class LoaderPlotter:
@@ -182,20 +187,25 @@ class LoaderPlotter:
 
         target_at = kwargs.pop('target_at') if 'target_at' in kwargs else None
         last_step = kwargs.pop('last_step') if 'last_step' in kwargs else False
+        crosshair_at = kwargs.pop('crosshair_at') if 'crosshair_at' in kwargs else None
 
         self.load_data(**kwargs)
-        self.show_data(target_at=target_at)
+        self.show_data(target_at=target_at,
+                       crosshair_at=crosshair_at)
         if (last_step and 'average_index' in kwargs and kwargs['average_index']
                 is not None):
             kwargs['last_step'] = last_step
             self.load_data(**kwargs)
-            self.show_data(target_at=target_at)
+            self.show_data(target_at=target_at,
+                           crosshair_at=crosshair_at)
 
     def show_data(self, **kwargs):
         """Send data to their dedicated viewers
         """
-        #self._init_show_data(self._data)
-        self.set_data_to_viewers(self._data, **kwargs)
+        try:
+            self.set_data_to_viewers(self._data, **kwargs)
+        except Exception as e:
+            logger.warning(f'Could not show data: {str(e)}')
 
     def _init_show_data(self, data: DataToExport):
         """Processing before showing data
@@ -203,7 +213,9 @@ class LoaderPlotter:
         self._viewer_types = [ViewersEnum(data.dim.name) for data in data]
         self.prepare_viewers(self._viewer_types)
 
-    def prepare_viewers(self, viewers_enum: List[ViewersEnum], viewers_name: List[str] = None):
+    def prepare_viewers(self, viewers_enum: List[Union[ViewersEnum, str]],
+                        viewers_name: List[str] = None) -> List[ViewerBase]:
+
         if self._viewers is not None:
             while len(self._viewers) > 0:
                 self._viewers.pop(list(self._viewers.keys())[0])
@@ -214,13 +226,16 @@ class LoaderPlotter:
             viewers_name = [f'DataPlot{ind:02d}' for ind in range(len(self._viewer_types))]
 
         if self.dispatcher.viewer_types != self._viewer_types:
-            self.dispatcher.update_viewers(self._viewer_types)
+            self.dispatcher.update_viewers(self._viewer_types,
+                                           viewers_name=viewers_name)
 
         self._viewers = dict(zip(viewers_name, self.dispatcher.viewers))
         self._viewer_docks = dict(zip(viewers_name, self.dispatcher.viewer_docks))
+        return self.dispatcher.viewers
 
     def set_data_to_viewers(self, data: DataToExport, temp=False,
-                            target_at: Iterable[float] = None):
+                            target_at: Iterable[float] = None,
+                            crosshair_at: Iterable[float] = None):
         """Process data dimensionality and send appropriate data to their data viewers
 
         Parameters
@@ -230,6 +245,8 @@ class LoaderPlotter:
             if True notify the data viewers to display data as temporary (meaning not exporting processed data from roi)
         target_at: Iterable[float]
             if specified show and plot the roi_target of each viewer at the given position
+        crosshair_at: Iterable[float]
+            if specified show and plot the viewer crosshair of each viewer at the given position
         See Also
         --------
         ViewerBase, Viewer0D, Viewer1D, Viewer2D
@@ -246,21 +263,27 @@ class LoaderPlotter:
                 viewer.show_data_temp(_data)
             else:
                 viewer.show_data(_data)
+            if crosshair_at is not None:
+                if not viewer.is_action_checked('crosshair'):
+                    viewer.get_action('crosshair').trigger()
+                viewer.double_clicked(*crosshair_at)
             if target_at is not None:
                 viewer.show_roi_target(True)
-                if _data.dim == 'Data1D':
+                if isinstance(viewer, Viewer1D):
                     viewer.move_roi_target(target_at)
-                elif _data.dim == 'Data2D' and _data.distribution == 'uniform':
+                elif isinstance(viewer, Viewer2D):
                     _target_at = target_at.copy()
-
-                    size = [_data.get_axis_from_index(1)[0].scaling]
-                    if len(_target_at) == 1:  # means concatenation of 1D data
-                        axis = _data.get_axis_from_index(0)[0]
-                        size.append(axis.scaling * axis.size)
-                        _target_at = list(_target_at) + [axis.offset]
+                    if _data.distribution == 'uniform':
+                        size = [_data.get_axis_from_index(1)[0].scaling]
+                        if len(_target_at) == 1:  # means concatenation of 1D data
+                            axis = _data.get_axis_from_index(0)[0]
+                            size.append(axis.scaling * axis.size)
+                            _target_at = list(_target_at) + [axis.offset]
+                        else:
+                            size.append(_data.get_axis_from_index(0)[0].scaling)
+                        viewer.move_roi_target(_target_at, size)
                     else:
-                        size.append(_data.get_axis_from_index(0)[0].scaling)
-                    viewer.move_roi_target(_target_at, size)
+                        viewer.move_roi_target(_target_at)
 
 def main(init_qt=True):
     if init_qt:  # used for the test suite

pymodaq/resources/VERSION

@@ -1 +1 @@
-version = '4.1.4'
+version = '4.2.0'

pymodaq/resources/config_template.toml

@@ -41,6 +41,9 @@ viewer_in_thread = true
 timeout = 10000  # default duration in ms to wait for data to be acquirred
 allow_settings_edition = false
 
+[plotting]
+backend = 'matplotlib'  # either 'matplotlib' or 'qt' or any other custom backend
+
 [network]
     [network.logging]
         [network.logging.user]
@@ -55,6 +58,11 @@ allow_settings_edition = false
     ip = "10.47.0.39"
     port = 6341
 
+    [network.leco-server]
+    run_coordinator_at_startup = false
+    host = "localhost"
+    port = 12300  # pyleco default Coordinator port
+
 [presets]
 default_preset_for_scan = "preset_default"
 default_preset_for_logger = "preset_default"
@@ -62,7 +70,7 @@ default_preset_for_pid = "beam_steering_mock"
 
 [actuator]
     epsilon_default = 1
-    polling_interval_ms = 100  # ms Carefull when using TCP/IP connection as you can saturate the connection with too much polling
+    polling_interval_ms = 100  # ms Careful when using TCP/IP connection as you can saturate the connection with too much polling
     polling_timeout_s = 20  # s
     refresh_timeout_ms = 500  # ms
     timeout = 10000  # default duration in ms to wait for data to be acquirred
@@ -80,26 +88,3 @@ default_preset_for_pid = "beam_steering_mock"
     wait_time_between = 0
     timeout = 10000  # in millisecond
 
-    [scan.scan1D]
-    type = "Linear" # either "Linear", "Adaptive", "Linear back to start", "Random" see pymodaq.utils.scanner.py
-    start = 1.0
-    stop = 2.0
-    step = 0.01
-    [scan.scan2D]
-    type = "Spiral" # either "Spiral", "Linear", "Adaptive", "Back&Forth", "Random" see pymodaq.utils.scanner.py
-        [scan.scan2D.spiral]
-        center1 = -5
-        center2 = 5
-        rmax1 = 10
-        rmax2 = 5
-        npts = 10
-        [scan.scan2D.linear]
-        start1 = -5
-        start2 = -5
-        stop1 = 5
-        stop2 = 5
-        step1 = 0.5
-        step2 = 0.5
-    [scan.tabular]
-    type = "Linear" #either "Linear", "Adaptive" see pymodaq.utils.scanner.py
-    curvilinear = 0.1

pymodaq/resources/setup_plugin.py

@@ -47,7 +47,7 @@ def setup(path: Path):
             entrypoints['pymodaq.instruments'] = f'{SHORT_PLUGIN_NAME} = {PLUGIN_NAME}'
         if config['features'].get('extensions', False):
             entrypoints['pymodaq.extensions'] = f'{SHORT_PLUGIN_NAME} = {PLUGIN_NAME}'
-        if config['features'].get('pid_models', False):
+        if config['features'].get('pid_models', False):  # deprecated use 'models'
             entrypoints['pymodaq.pid_models'] = f'{SHORT_PLUGIN_NAME} = {PLUGIN_NAME}'
         if config['features'].get('models', False):
             entrypoints['pymodaq.models'] = f'{SHORT_PLUGIN_NAME} = {PLUGIN_NAME}'

pymodaq/utils/config.py

@@ -1,13 +1,18 @@
 from abc import abstractproperty
+from collections.abc import Iterable
 
 from os import environ
 import sys
 import datetime
 from pathlib import Path
-from typing import Union, Dict, TypeVar, Any
+from typing import Union, Dict, TypeVar, Any, List, TYPE_CHECKING
+from typing import Iterable as IterableType
 
 import toml
 
+if TYPE_CHECKING:
+    from pymodaq.utils.parameter import Parameter
+
 
 try:
     USER = environ['USERNAME'] if sys.platform == 'win32' else environ['USER']
@@ -80,6 +85,16 @@ def getitem_recursive(dic, *args, ndepth=0, create_if_missing=False):
     return dic
 
 
+def recursive_iterable_flattening(aniterable: IterableType):
+    flatten_iter = []
+    for elt in aniterable:
+        if not isinstance(elt, str) and isinstance(elt, Iterable):
+            flatten_iter.extend(recursive_iterable_flattening(elt))
+        else:
+            flatten_iter.append(elt)
+    return flatten_iter
+
+
 def get_set_path(a_base_path: Path, dir_name: str) -> Path:
     path_to_get = a_base_path.joinpath(dir_name)
     if not path_to_get.is_dir():
@@ -249,7 +264,7 @@ def copy_template_config(config_file_name: str = 'config', source_path: Union[Pa
     dest_path_with_filename = dest_path.joinpath(file_name)
 
     if source_path is None:
-        config_template_dict = toml.load(Path(__file__).parent.parent.joinpath('resources/config_template.toml'))
+        config_template_dict = {}
     else:
         config_template_dict = toml.load(Path(source_path))
 
@@ -322,9 +337,18 @@ class BaseConfig:
         else:
             return self._config[item]
 
+    # def __setitem__(self, key, value):
+    #     if isinstance(key, tuple):
+    #         dic = getitem_recursive(self._config, *key, ndepth=1, create_if_missing=False)
+    #         dic[key[-1]] = value
+    #     else:
+    #         self._config[key] = value
+
     def __setitem__(self, key, value):
         if isinstance(key, tuple):
-            dic = getitem_recursive(self._config, *key, ndepth=1, create_if_missing=False)
+            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
@@ -337,7 +361,10 @@ class BaseConfig:
         toml_user_path = get_config_file(config_file_name, user=True)
         if toml_base_path.is_file():
             config = toml.load(toml_base_path)
-            config_template = toml.load(template_path)
+            if template_path is not None:
+                config_template = toml.load(template_path)
+            else:
+                config_template = {}
             if check_config(config_template, config):  # check if all fields from template are there
                 # (could have been  modified by some commits)
                 create_toml_from_dict(config, toml_base_path)
@@ -383,8 +410,79 @@ class Config(BaseConfig):
         return dict(user=dict(name=USER))
 
 
+class ConfigSaverLoader:
+    """ Allows to set Parameters values from previously saved one in a configuration file
+
+    This plays the role of a cache for these Parameters
+
+    Parameters
+    ----------
+    base_param: Parameter
+        The parent Parameter whose children should be cached in the config file
+    config: BaseConfig
+        The Config object that will cache the Parameter values
+    base_path: Iterable[str]
+        an iterable of string defining a "category"
+    """
+
+    def __init__(self, base_param: 'Parameter', config: BaseConfig,
+                 base_path: IterableType[str] = None):
+        self.config = config
+        if base_path is None:
+            base_path = []
+        self._base_path: List[str] = list(recursive_iterable_flattening(base_path))
+        self._base_param = base_param
+
+    @property
+    def base_path(self):
+        """ Get/Set the iterable of string defining a particular configuration to be loaded/saved"""
+        return self._base_path
+
+    @base_path.setter
+    def base_path(self, path: IterableType[str]):
+        self._base_path = list(recursive_iterable_flattening(path))
+
+    @property
+    def base_param(self):
+        """ Get/Set the parent Parameter whose children should be saved in the config file"""
+        return self._base_param
+
+    @base_param.setter
+    def base_param(self, param: 'Parameter'):
+        self._base_param = param
+
+    def load_config(self, param: 'Parameter' = None):
+        from pymodaq.utils.parameter import utils as putils
+
+        if param is None:
+            param = self.base_param
+        base_path = self.base_path[:]
+        for child in putils.iter_children_params(param, []):
+            if len(child.children()) == 0:  # means it is not a group parameter
+
+                path = base_path + putils.get_param_path(child)[1:]
+
+                try:
+                    child.setValue(self.config(
+                        *path))  # first try to load the config including the actuators name
+                except ConfigError as e:
+                    pass
+            else:
+                self.load_config(child)
+
+    def save_config(self):
+        from pymodaq.utils.parameter import utils as putils
+
+        for param in putils.iter_children_params(self.base_param, []):
+            path_param = self.base_path[:]
+            path_param.extend(putils.get_param_path(param)[1:])
+            try:
+                self.config[tuple(path_param)] = param.value()
+            except Exception as e:
+                pass
+        self.config.save()
+
 
-    
 if __name__ == '__main__':
 
     config = Config()

pymodaq/utils/daq_utils.py

@@ -15,6 +15,8 @@ import pkgutil
 import traceback
 import platform
 from typing import Union, List
+from typing import Iterable as IterableType
+from collections.abc import Iterable
 
 import numpy as np
 from qtpy import QtCore
@@ -38,44 +40,12 @@ else:
     from functools import lru_cache as cache
 
 
-if version_mod.parse(platform.python_version()) >= version_mod.parse('3.9'):
-    # from version 3.9 the cache decorator is available
-    from functools import cache
-else:
-    from functools import lru_cache as cache
-
 logger = logger_module.set_logger(logger_module.get_module_name(__file__))
 
 plot_colors = [(255, 255, 255), (255, 0, 0), (0, 255, 0), (0, 0, 255), (14, 207, 189), (207, 14, 166), (207, 204, 14)]
 config = Config()
 
 
-def __getattr__(name):
-    if name in ['Axis', 'NavAxis', 'ScaledAxis', 'ScalingOptions', 'Data', 'DataTimeStamped', 'DataFromPlugins',
-                'DataToEmit', 'DataToExport']:
-        data_mod = importlib.import_module('.data', 'pymodaq.utils')
-        deprecation_msg('Loading Axis or Data and their derived classes from daq_utils is deprecated, import them from'
-                        ' pymodaq.utils.data module', 3)
-        return getattr(data_mod, name)
-    else:
-        raise AttributeError
-
-
-def load_config():
-    deprecation_msg(f'config methods must now be  imported from the pymodaq.utils.messenger.cnfig module')
-    return Config()
-
-
-def set_logger(*args, **kwargs):
-    deprecation_msg(f'Logger methods must now be  imported from the pymodaq.utils.logger module', 3)
-    return logger_module.set_logger(*args, **kwargs)
-
-
-def get_module_name(*args, **kwargs):
-    deprecation_msg(f'Logger methods must now be  imported from the pymodaq.utils.logger module', 3)
-    return logger_module.get_module_name(*args, **kwargs)
-
-
 def is_64bits():
     return sys.maxsize > 2**32
 
@@ -261,7 +231,7 @@ class ThreadCommand:
             raise TypeError(f'The command in a Threadcommand object should be a string, not a {type(command)}')
         self.command = command
         if attribute is None and attributes is not None:
-            deprecation_msg('ThreadCommand signature changed, use attribute in place of attribute')
+            deprecation_msg('ThreadCommand signature changed, use attribute in place of attributes')
             self.attribute = attributes
             self.attributes = attributes
         self.attribute = attribute
@@ -554,7 +524,7 @@ def find_dict_in_list_from_key_val(dicts, key, value, return_index=False):
         return None
 
 
-def get_entrypoints(group='pymodaq.plugins'):
+def get_entrypoints(group='pymodaq.plugins') -> List[metadata.EntryPoint]:
     """ Get the list of modules defined from a group entry point
 
     Because of evolution in the package, one or another of the forms below may be deprecated.
@@ -574,6 +544,8 @@ def get_entrypoints(group='pymodaq.plugins'):
             discovered_entrypoints = metadata.entry_points().get(group, [])
     if isinstance(discovered_entrypoints, tuple):  # API for python > 3.8
         discovered_entrypoints = list(discovered_entrypoints)
+    if not isinstance(discovered_entrypoints, list):
+        discovered_entrypoints = list(discovered_entrypoints)
     return discovered_entrypoints
 
 
@@ -592,16 +564,18 @@ def get_instrument_plugins():  # pragma: no cover
     """
     plugins_import = []
     discovered_plugins = []
-    discovered_plugins_all = get_entrypoints(group='pymodaq.plugins')  # old naming of the instrument plugins
-    discovered_plugins_all.extend(get_entrypoints(group='pymodaq.instruments'))  # new naming convention
+    discovered_plugins_all = list(get_entrypoints(group='pymodaq.plugins'))  # old naming of the instrument plugins
+    discovered_plugins_all.extend(list(get_entrypoints(group='pymodaq.instruments')))  # new naming convention
     for entry in discovered_plugins_all:
         if entry.name not in [ent.name for ent in discovered_plugins]:
             discovered_plugins.append(entry)
+    discovered_plugins = list(set(discovered_plugins))
     logger.debug(f'Found {len(discovered_plugins)} installed plugins, trying to import them')
     viewer_types = ['0D', '1D', '2D', 'ND']
+    plugin_list = []
     for entrypoint in discovered_plugins:
         #print(f'Looking for valid instrument plugins in package: {module.value}')
-        plugin_list = []
+
         try:
             try:
                 movemodule = importlib.import_module(f'{entrypoint.value}.daq_move_plugins', entrypoint.value)
@@ -611,8 +585,12 @@ def get_instrument_plugins():  # pragma: no cover
                                      'type': 'daq_move'}
                                     for mod in [mod[1] for mod in pkgutil.iter_modules([str(movemodule.path.parent)])]
                                     if 'daq_move' in mod])
+                if len(plugin_list) > 0:
+                    logger.debug(f"Found Move Instrument:"
+                                f" {plugin_list[-1]['module'].__name__}/{plugin_list[-1]['name']}")
             except ModuleNotFoundError:
                 pass
+
             viewer_modules = {}
             for vtype in viewer_types:
                 try:
@@ -624,27 +602,32 @@ def get_instrument_plugins():  # pragma: no cover
                                      'type': f'daq_{vtype}viewer'}
                                     for mod in [mod[1] for mod in pkgutil.iter_modules([str(viewer_modules[vtype].path.parent)])]
                                     if f'daq_{vtype}viewer' in mod])
+                    if len(plugin_list) > 0:
+                        logger.debug(f"Found Viewer Instrument: "
+                                    f"{plugin_list[-1]['module'].__name__}/{plugin_list[-1]['name']}")
                 except ModuleNotFoundError:
                     pass
 
-            # check if modules are importable
-            for mod in plugin_list:
-                try:
-                    plugin_type = mod['type']
-                    if plugin_type == 'daq_move':
-                        submodule = mod['module']
-                        importlib.import_module(f'{submodule.__package__}.daq_move_{mod["name"]}')
-                    else:
-                        submodule = mod['module']
-                        importlib.import_module(f'{submodule.__package__}.daq_{plugin_type[4:6]}viewer_{mod["name"]}')
-                    plugins_import.append(mod)
-                except Exception as e:  # pragma: no cover
-                    """If an error is generated at the import, then exclude this plugin"""
-                    logger.debug(f'Impossible to import Instrument plugin {mod["name"]}'
-                                 f' from module: {mod["parent_module"].__package__}')
         except Exception as e:  # pragma: no cover
             logger.debug(str(e))
-            
+
+    for mod in plugin_list:
+        try:
+            plugin_type = mod['type']
+            if plugin_type == 'daq_move':
+                submodule = mod['module']
+                importlib.import_module(f'{submodule.__package__}.daq_move_{mod["name"]}')
+            else:
+                submodule = mod['module']
+                importlib.import_module(f'{submodule.__package__}.daq_{plugin_type[4:6]}viewer_{mod["name"]}')
+            plugins_import.append(mod)
+            logger.info(f"{mod['module'].__name__}/{mod['name']} available")
+        except Exception as e:  # pragma: no cover
+            """If an error is generated at the import, then exclude this plugin"""
+            logger.debug(f'Impossible to import Instrument plugin {mod["name"]}'
+                         f' from module: {mod["parent_module"].__package__}')
+
+
     # add utility plugin for PID
     try:
         pidmodule = importlib.import_module('pymodaq.extensions.pid')
@@ -660,6 +643,7 @@ def get_instrument_plugins():  # pragma: no cover
 
     return plugins_import
 
+
 def get_plugins(plugin_type='daq_0Dviewer'):  # pragma: no cover
     """
     Get plugins names as a list
@@ -768,91 +752,6 @@ def get_new_file_name(base_path=Path(config('data_saving', 'h5file', 'save_path'
     return file, curr_dir
 
 
-# ##############
-# Math utilities
-# math utility functions, should now be imported from the math_utils module
-import pymodaq.utils.math_utils as mutils
-
-def my_moment(x, y):
-    deprecation_msg(f'my_moment function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.my_moment(x, y)
-
-def normalize(x):
-    deprecation_msg(f'normalize function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.normalize(x)
-
-
-def odd_even(x):
-    deprecation_msg(f'odd_even function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.odd_even(x)
-
-
-def greater2n(x):
-    deprecation_msg(f'greater2n function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.greater2n(x)
-
-
-def linspace_step(start, stop, step):
-    deprecation_msg(f'linspace_step function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.linspace_step(start, stop, step)
-
-
-def linspace_step_N(start, step, Npts):
-    deprecation_msg(f'linspace_step_N function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.linspace_step_N(start, step, Npts)
-
-
-def find_index(x, threshold):
-    deprecation_msg(f'find_index function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.find_index(x, threshold)
-
-
-def find_common_index(x, y, x0, y0):
-    deprecation_msg(f'find_common_index function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.find_common_index(x, y, x0, y0)
-
-
-def gauss1D(x, x0, dx, n=1):
-    deprecation_msg(f'gauss1D function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.gauss1D(x, x0, dx, n=n)
-
-
-def gauss2D(x, x0, dx, y, y0, dy, n=1, angle=0):
-    deprecation_msg(f'gauss2D function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.gauss2D(x, x0, dx, y, y0, dy, n, angle)
-
-def ftAxis(Npts, omega_max):
-    deprecation_msg(f'ftAxis function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ftAxis(Npts, omega_max)
-
-
-def ftAxis_time(Npts, time_max):
-    deprecation_msg(f'ftAxis_time function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ftAxis_time(Npts, time_max)
-
-
-def ft(x, dim=-1):
-    deprecation_msg(f'ft function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ft(x, dim)
-
-
-def ift(x, dim=0):
-    deprecation_msg(f'ift function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ift(x, dim)
-
-
-def ft2(x, dim=(-2, -1)):
-    deprecation_msg(f'ft2 function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ft2(x, dim)
-
-
-def ift2(x, dim=(-2, -1)):
-    deprecation_msg(f'ift2 function should now be imported from the {mutils.__name__} module', stacklevel=3)
-    return mutils.ift2(x, dim)
-
-
-
-
 if __name__ == '__main__':
     #paths = recursive_find_expr_in_files('C:\\Users\\weber\\Labo\\Programmes Python\\PyMoDAQ_Git', 'visa')
     # for p in paths: