nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/resources/logger.py

@@ -1,130 +0,0 @@
-import logging
-import logging.config
-
-
-class Logger(object):
-    def __init__(self, loggername, level="DEBUG", logfile="logger.log", console=True):
-        """
-        Configure a Logger object.
-
-        Parameters
-        -----------
-        loggername: str
-            Logger name.
-        level: str, optional
-            Logging level. Can be "debug", "info", "warning", "error", "critical".
-            Default is "debug".
-        logfile: str, optional
-            File where the logs are written.
-            If set to None, the logs are not written in a file.
-            Default is "logger.log".
-        console: bool, optional
-            If set to True, the logs are (also) written in stdout/stderr.
-            Default is True.
-        """
-        self.loggername = loggername
-        self.level = level
-        self.logfile = logfile
-        self.console = console
-        self._configure_logger()
-
-    def _configure_logger(self):
-        conf = self._get_default_config_dict()
-        for handler in conf["handlers"].keys():
-            conf["handlers"][handler]["level"] = self.level.upper()
-        conf["loggers"][self.loggername]["level"] = self.level.upper()
-        if not (self.console):
-            conf["loggers"][self.loggername]["handlers"].remove("console")
-
-        self.config = conf
-        logging.config.dictConfig(conf)
-        self.logger = logging.getLogger(self.loggername)
-
-    def _get_default_config_dict(self):
-        conf = {
-            "version": 1,
-            "formatters": {
-                "default": {"format": "%(asctime)s - %(levelname)s - %(message)s", "datefmt": "%d-%m-%Y %H:%M:%S"},
-                "console": {"format": "%(message)s"},
-            },
-            "handlers": {
-                "console": {
-                    "level": "DEBUG",
-                    "class": "logging.StreamHandler",
-                    "formatter": "console",
-                    "stream": "ext://sys.stdout",
-                },
-                "file": {
-                    "level": "DEBUG",
-                    "class": "logging.FileHandler",
-                    "formatter": "default",
-                    "filename": self.logfile,
-                },
-            },
-            "loggers": {
-                self.loggername: {
-                    "level": "DEBUG",
-                    "handlers": ["console", "file"],
-                    # This logger inherits from root logger - dont propagate !
-                    "propagate": False,
-                }
-            },
-            "disable_existing_loggers": False,
-        }
-        return conf
-
-    def info(self, msg):
-        return self.logger.info(msg)
-
-    def debug(self, msg):
-        return self.logger.debug(msg)
-
-    def warning(self, msg):
-        return self.logger.warning(msg)
-
-    warn = warning
-
-    def error(self, msg):
-        return self.logger.error(msg)
-
-    def fatal(self, msg):
-        return self.logger.fatal(msg)
-
-    def critical(self, msg):
-        return self.logger.critical(msg)
-
-
-def LoggerOrPrint(logger):
-    """
-    Logger that is either a "true" logger object, or a fall-back to "print".
-    """
-    if logger is None:
-        return PrinterLogger()
-    return logger
-
-
-class PrinterLogger(object):
-    def __init__(self):
-        methods = [
-            "debug",
-            "warn",
-            "warning",
-            "info",
-            "error",
-            "fatal",
-            "critical",
-        ]
-        for method in methods:
-            self.__setattr__(method, print)
-
-
-LogLevel = {
-    "notset": logging.NOTSET,
-    "debug": logging.DEBUG,
-    "info": logging.INFO,
-    "warn": logging.WARN,
-    "warning": logging.WARNING,
-    "error": logging.ERROR,
-    "critical": logging.CRITICAL,
-    "fatal": logging.FATAL,
-}

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/resources/nxflatfield.py

@@ -1,217 +0,0 @@
-import os
-import numpy as np
-from silx.io.url import DataUrl
-from tomoscan.io import HDF5File
-from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
-from ..utils import check_supported, is_writeable
-
-
-def get_frame_possible_urls(dataset_info, user_dir, output_dir, frame_type):
-    """
-    Return a list with the possible location of reduced dark/flat frames.
-
-    Parameters
-    ----------
-    dataset_info: DatasetAnalyzer object
-        DatasetAnalyzer object: data structure containing information on the parsed dataset
-    user_dir: str or None
-        User-provided directory location for the reduced frames.
-    output_dir: str or None
-        Output processing directory
-    frame_type: str
-        Frame type, can be "flats" or "darks".
-    """
-    check_supported(frame_type, ["flats", "darks"], "frame type")
-
-    h5scan = dataset_info.dataset_scanner  # tomoscan object
-    if frame_type == "flats":
-        dataurl_default_template = h5scan.REDUCED_FLATS_DATAURLS[0]
-    else:
-        dataurl_default_template = h5scan.REDUCED_DARKS_DATAURLS[0]
-
-    def make_dataurl(dirname):
-        # The template formatting should be done by tomoscan in principle, but this complicates logging.
-        rel_file_path = dataurl_default_template.file_path().format(
-            scan_prefix=dataset_info.dataset_scanner.get_dataset_basename()
-        )
-        return DataUrl(
-            file_path=os.path.join(dirname, rel_file_path),
-            data_path=dataurl_default_template.data_path(),
-            data_slice=dataurl_default_template.data_slice(),  # not sure if needed
-            scheme="silx",
-        )
-
-    urls = {"user": None, "dataset": None, "output": None}
-
-    if user_dir is not None:
-        urls["user"] = make_dataurl(user_dir)
-
-    # tomoscan.esrf.scan.hdf5scan.REDUCED_{DARKS|FLATS}_DATAURLS.file_path() is a relative path
-    # Create a absolute path instead
-    urls["dataset"] = make_dataurl(os.path.dirname(h5scan.master_file))
-
-    if output_dir is not None:
-        urls["output"] = make_dataurl(output_dir)
-
-    return urls
-
-
-def get_metadata_url(url, frame_type):
-    """
-    Return the url of the metadata stored alongside flats/darks
-    """
-    check_supported(frame_type, ["flats", "darks"], "frame type")
-    template_url = getattr(NXtomoScan, "REDUCED_%s_METADATAURLS" % frame_type.upper())[0]
-    return DataUrl(
-        file_path=url.file_path(),
-        data_path=template_url.data_path(),
-        scheme="silx",
-    )
-
-
-def tomoscan_load_reduced_frames(dataset_info, frame_type, url):
-    tomoscan_method = getattr(dataset_info.dataset_scanner, "load_reduced_%s" % frame_type)
-    return tomoscan_method(
-        inputs_urls=[url],
-        return_as_url=True,
-        return_info=True,
-        metadata_input_urls=[get_metadata_url(url, frame_type)],
-    )
-
-
-def tomoscan_save_reduced_frames(dataset_info, frame_type, url, frames, info):
-    tomoscan_method = getattr(dataset_info.dataset_scanner, "save_reduced_%s" % frame_type)
-    kwargs = {"%s_infos" % frame_type: info, "overwrite": True}
-    return tomoscan_method(
-        frames, output_urls=[url], metadata_output_urls=[get_metadata_url(url, frame_type)], **kwargs
-    )
-
-
-# pylint: disable=E1136
-def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=None, darks_flats_dir=None):
-    """
-    Update a DatasetAnalyzer object with reduced flats/darks (hereafter "reduced frames").
-
-    How the reduced frames are loaded/computed/saved will depend on the "flatfield_mode" parameter.
-
-    The principle is the following:
-    (1) Attempt at loading already-computed reduced frames (XXX_darks.h5 and XXX_flats.h5):
-       - First check files in the user-defined directory 'darks_flats_dir'
-       - Then try to load from files located alongside the .nx dataset (dataset directory)
-       - Then try to load from output_dir, if provided
-    (2) If loading fails, or flatfield_mode == "force_compute", compute the reduced frames.
-    (3) Save these reduced frames
-       - Save in darks_flats_dir, if provided by user
-       - Otherwise, save in the data directory (next to the .nx file), if write access OK
-       - Otherwise, save in output directory
-    """
-    if flatfield_mode is False:
-        return
-    logger = dataset_info.logger
-    frames_types = ["darks", "flats"]
-
-    reduced_frames_urls = {}
-    for frame_type in frames_types:
-        reduced_frames_urls[frame_type] = get_frame_possible_urls(dataset_info, darks_flats_dir, output_dir, frame_type)
-
-    reduced_frames = dict.fromkeys(frames_types, None)
-
-    #
-    # Try to load frames
-    #
-    def load_reduced_frame(url, frame_type, frames_loaded, reduced_frames):
-        if frames_loaded[frame_type]:
-            return
-        frames, info = tomoscan_load_reduced_frames(dataset_info, frame_type, url)
-        if frames not in (None, {}):
-            dataset_info.logger.info("Loaded %s from %s" % (frame_type, url.file_path()))
-            frames_loaded[frame_type] = True
-            reduced_frames[frame_type] = frames, info
-        else:
-            msg = "Could not load %s from %s" % (frame_type, url.file_path())
-            logger.error(msg)
-
-    frames_loaded = dict.fromkeys(frames_types, False)
-    if flatfield_mode != "force-compute":
-        for load_from in ["user", "dataset", "output"]:  # in that order
-            for frame_type in frames_types:
-                url = reduced_frames_urls[frame_type][load_from]
-                if url is None:
-                    continue  # cannot load from this source (eg. undefined folder)
-                load_reduced_frame(url, frame_type, frames_loaded, reduced_frames)
-            if all(frames_loaded.values()):
-                break
-
-    if not all(frames_loaded.values()) and flatfield_mode == "force-load":
-        raise ValueError("Could not load darks/flats (using 'force-load')")
-
-    #
-    # COMPAT. Keep DataUrl - won't be needed in future versions when pipeline will use FlatField
-    # instead of FlatFieldDataUrl
-    frames_urls = reduced_frames.copy()
-    #
-
-    # Compute reduced frames, if needed
-    #
-    if reduced_frames["flats"] is None:
-        reduced_frames["flats"] = dataset_info.dataset_scanner.compute_reduced_flats(return_info=True)
-    if reduced_frames["darks"] is None:
-        reduced_frames["darks"] = dataset_info.dataset_scanner.compute_reduced_darks(return_info=True)
-
-    if reduced_frames["darks"][0] == {} or reduced_frames["flats"][0] == {}:
-        raise ValueError(
-            "Could not get any reduced flat/dark. This probably means that no already-reduced flats/darks were found and that the dataset itself does not have any flat/dark"
-        )
-
-    #
-    # Save reduced frames
-    #
-
-    def save_reduced_frame(url, frame_type, frames_saved):
-        frames, info = reduced_frames[frame_type]
-        tomoscan_save_reduced_frames(dataset_info, frame_type, url, frames, info)
-        dataset_info.logger.info("Saved reduced %s to %s" % (frame_type, url.file_path()))
-        frames_saved[frame_type] = True
-
-    frames_saved = dict.fromkeys(frames_types, False)
-    if not all(frames_loaded.values()):
-        for save_to in ["user", "dataset", "output"]:  # in that order
-            for frame_type in frames_types:
-                if frames_loaded[frame_type]:
-                    continue  # already loaded
-                url = reduced_frames_urls[frame_type][save_to]
-                if url is None:
-                    continue  # cannot load from this source (eg. undefined folder)
-                if not is_writeable(os.path.dirname(url.file_path())):
-                    continue
-                save_reduced_frame(url, frame_type, frames_saved)
-                # COMPAT.
-                if frames_urls[frame_type] is None:
-                    frames_urls[frame_type] = tomoscan_load_reduced_frames(dataset_info, frame_type, url)
-                #
-            if all(frames_saved.values()):
-                break
-
-    dataset_info.flats = frames_urls["flats"][0]  # reduced_frames["flats"] # in future versions
-    dataset_info.flats_srcurrent = frames_urls["flats"][1].machine_electric_current
-    # This is an extra check to avoid having more than 1 (reduced) dark.
-    # FlatField only works with exactly 1 (reduced) dark (having more than 1 series of darks makes little sense)
-    # This is normally prevented by tomoscan HDF5FramesReducer, but let's add this extra check
-    darks_ = frames_urls["darks"][0]  # reduced_frames["darks"] # in future versions
-    if len(darks_) > 1:
-        dark_idx = sorted(darks_.keys())[0]
-        dataset_info.logger.error("Found more that one series of darks. Keeping only the first one")
-        darks_ = {dark_idx: darks_[dark_idx]}
-    #
-    dataset_info.darks = darks_
-    dataset_info.darks_srcurrent = frames_urls["darks"][1].machine_electric_current
-
-
-# tomoscan "compute_reduced_XX" is quite slow. If needed, here is an alternative implementation
-def my_reduce_flats(di):
-    res = {}
-    with HDF5File(di.dataset_hdf5_url.file_path(), "r") as f:
-        for data_slice in di.get_data_slices("flats"):
-            data = f[di.dataset_hdf5_url.data_path()][data_slice.start : data_slice.stop]
-            res[data_slice.start] = np.median(data, axis=0)
-    return res

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/resources/tests/test_nxflatfield.py

@@ -1,104 +0,0 @@
-from os import path
-from tempfile import mkdtemp
-from shutil import rmtree
-import pytest
-import numpy as np
-from silx.io import get_data
-from nxtomo.nxobject.nxdetector import ImageKey
-from nabu.testutils import generate_nx_dataset
-from nabu.resources.nxflatfield import update_dataset_info_flats_darks
-from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
-
-
-test_nxflatfield_scenarios = [
-    {
-        "name": "simple",
-        "flats_pos": [slice(1, 6)],
-        "darks_pos": [slice(0, 1)],
-        "output_dir": None,
-    },
-    {
-        "name": "simple_with_save",
-        "flats_pos": [slice(1, 6)],
-        "darks_pos": [slice(0, 1)],
-        "output_dir": None,
-    },
-    {
-        "name": "multiple_with_save",
-        "flats_pos": [slice(0, 10), slice(30, 40)],
-        "darks_pos": [slice(95, 100)],
-        "output_dir": path.join("{tempdir}", "output_reduced"),
-    },
-]
-
-
-# parametrize with fixture and "params=" will launch a new class for each scenario.
-# the attributes set to "cls" will remain for all the tests done in this class
-# with the current scenario.
-@pytest.fixture(scope="class", params=test_nxflatfield_scenarios)
-def bootstrap(request):
-    cls = request.cls
-    cls.n_projs = 265
-    cls.params = request.param
-    cls.tempdir = mkdtemp(prefix="nabu_")
-    yield
-    rmtree(cls.tempdir)
-
-
-@pytest.mark.usefixtures("bootstrap")
-class TestNXFlatField:
-    _reduction_func = {"flats": np.median, "darks": np.mean}
-
-    def get_nx_filename(self):
-        return path.join(self.tempdir, "dataset_" + self.params["name"] + ".nx")
-
-    def get_image_key(self):
-        keys = np.zeros(self.n_projs, np.int32)
-        for what, val in [("flats_pos", ImageKey.FLAT_FIELD.value), ("darks_pos", ImageKey.DARK_FIELD.value)]:
-            for pos in self.params[what]:
-                keys[pos.start : pos.stop] = val
-        return keys
-
-    @staticmethod
-    def check_image_key(dataset_info, frame_type, expected_slices):
-        data_slices = dataset_info.get_data_slices(frame_type)
-        assert set(map(str, data_slices)) == set(map(str, expected_slices))
-
-    def test_nxflatfield(self):
-        dataset_fname = self.get_nx_filename()
-        image_key = self.get_image_key()
-        generate_nx_dataset(dataset_fname, image_key)
-
-        dataset_info = HDF5DatasetAnalyzer(dataset_fname)
-
-        # When parsing a "raw" dataset, flats/darks are a series of images.
-        # dataset_info.flats is a dictionary where each key is the index of the frame.
-        # For example dataset_info.flats.keys() = [10, 11, 12, 13, ..., 19, 1200, 1201, 1202, ..., 1219]
-        for frame_type in ["darks", "flats"]:
-            self.check_image_key(dataset_info, frame_type, self.params[frame_type + "_pos"])
-
-        output_dir = self.params.get("output_dir", None)
-        if output_dir is not None:
-            output_dir = output_dir.format(tempdir=self.tempdir)
-        update_dataset_info_flats_darks(dataset_info, True, output_dir=output_dir)
-        # After reduction (median/mean), the flats/darks are located in another file.
-        # median(series_1) goes to entry/flats/idx1, mean(series_2) goes to entry/flats/idx2, etc.
-        assert set(dataset_info.flats.keys()) == set(s.start for s in self.params["flats_pos"])
-        assert set(dataset_info.darks.keys()) == set(s.start for s in self.params["darks_pos"])
-
-        # Check that the computations were correct
-        # Loads the entire volume in memory ! So keep the data volume small for the tests
-        data_volume = get_data(dataset_info.dataset_hdf5_url)
-        expected_flats = {}
-        for s in self.params["flats_pos"]:
-            expected_flats[s.start] = self._reduction_func["flats"](data_volume[s.start : s.stop], axis=0)
-        expected_darks = {}
-        for s in self.params["darks_pos"]:
-            expected_darks[s.start] = self._reduction_func["darks"](data_volume[s.start : s.stop], axis=0)
-
-        flats = {idx: get_data(dataset_info.flats[idx]) for idx in dataset_info.flats.keys()}
-        for idx in flats.keys():
-            assert np.allclose(flats[idx], expected_flats[idx])
-        darks = {idx: get_data(dataset_info.darks[idx]) for idx in dataset_info.darks.keys()}
-        for idx in darks.keys():
-            assert np.allclose(darks[idx], expected_darks[idx])

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/resources/tests/test_units.py

@@ -1,47 +0,0 @@
-import pytest
-from nabu.utils import compare_dicts
-from nabu.resources.utils import get_quantities_and_units
-
-
-class TestUnits:
-    expected_results = {
-        "distance = 1 m ; pixel_size = 2.0 um": {"distance": 1.0, "pixel_size": 2e-6},
-        "distance = 1 m ; pixel_size = 2.6 micrometer": {"distance": 1.0, "pixel_size": 2.6e-6},
-        "distance = 10 m ; pixel_size = 2e-6 m": {"distance": 10, "pixel_size": 2e-6},
-        "distance = .5 m ; pixel_size = 2.6e-4 centimeter": {"distance": 0.5, "pixel_size": 2.6e-6},
-        "distance = 10 cm ; pixel_size = 2.5 micrometer ; energy = 1 ev": {
-            "distance": 0.1,
-            "pixel_size": 2.5e-6,
-            "energy": 1.0e-3,
-        },
-        "distance = 10 cm ; pixel_size = 9.0e-3 millimeter ; energy = 19 kev": {
-            "distance": 0.1,
-            "pixel_size": 9e-6,
-            "energy": 19.0,
-        },
-    }
-    expected_failures = {
-        # typo ("ke" instead of "kev")
-        "distance = 10 cm ; energy = 10 ke": ValueError("Cannot convert: ke"),
-        # No units
-        "distance = 10 ; energy = 10 kev": ValueError("not enough values to unpack (expected 2, got 1)"),
-        # Unit not separated by space
-        "distance = 10m; energy = 10 kev": ValueError("not enough values to unpack (expected 2, got 1)"),
-        # Invalid separator
-        "distance = 10 m, energy = 10 kev": ValueError("too many values to unpack (expected 2)"),
-    }
-
-    def test_conversion(self):
-        for test_str, expected_result in self.expected_results.items():
-            res = get_quantities_and_units(test_str)
-            err_msg = str(
-                "Something wrong with quantities/units extraction from '%s': expected %s, got %s"
-                % (test_str, str(expected_result), str(res))
-            )
-            assert compare_dicts(res, expected_result) is None, err_msg
-
-    def test_valid_input(self):
-        for test_str, expected_failure in self.expected_failures.items():
-            with pytest.raises(type(expected_failure)) as e_info:
-                get_quantities_and_units(test_str)
-            assert e_info.value.args[0] == str(expected_failure)

build/lib/build/lib/build/lib/build/lib/build/lib/nabu/resources/utils.py

@@ -1,174 +0,0 @@
-from ast import literal_eval
-import numpy as np
-from psutil import virtual_memory, cpu_count
-from pyunitsystem.metricsystem import MetricSystem
-from pyunitsystem.energysystem import EnergySI
-
-
-def get_values_from_file(fname, n_values=None, shape=None, sep=None, any_size=False):
-    """
-    Read a text file and scan the values inside.
-    This function expects one value per line, or values separated with a separator
-    defined with the `sep` parameter.
-
-    Parameters
-    ----------
-    fname: str
-        Path of the text file
-    n_values: int, optional
-        If set to a value, this function will check that it scans exactly this
-        number of values.
-        Ignored if `shape` is provided
-    shape: tuple, optional
-        Generalization of n_values for higher dimensions.
-    sep: str, optional
-        Separator between values. Default is white space
-    any_size: bool, optional
-        If set to True, then the parameters 'n_values' and 'shape' are ignored.
-
-    Returns
-    --------
-    arr: numpy.ndarray
-        An array containing the values scanned from the text file
-    """
-    if not (any_size) and not ((n_values is not None) ^ (shape is not None)):
-        raise ValueError("Please provide either n_values or shape")
-    arr = np.loadtxt(fname, ndmin=1)
-    if (n_values is not None) and (arr.shape[0] != n_values):
-        if any_size:
-            arr = arr[:n_values]
-        else:
-            raise ValueError("Expected %d values, but could get %d values" % (n_values, arr.shape[0]))
-    if (shape is not None) and (arr.shape != shape):
-        if any_size:
-            arr = arr[: shape[0], : shape[1]]  # TODO handle more dimensions ?
-        else:
-            raise ValueError("Expected shape %s, but got shape %s" % (shape, arr.shape))
-    return arr
-
-
-def get_memory_per_node(max_mem, is_percentage=True):
-    """
-    Get the available memory per node in GB.
-
-    Parameters
-    ----------
-    max_mem: float
-        If is_percentage is False, then number is interpreted as an absolute
-        number in GigaBytes.
-        Otherwise, it should be a number between 0 and 100 and is interpreted
-        as a percentage.
-    is_percentage: bool
-        A boolean indicating whether the parameter max_mem is to be interpreted
-        as a percentage of available system memory.
-    """
-    sys_avail_mem = virtual_memory().available / 1e9
-    if is_percentage:
-        return (max_mem / 100.0) * sys_avail_mem
-    else:
-        return min(max_mem, sys_avail_mem)
-
-
-def get_threads_per_node(max_threads, is_percentage=True):
-    """
-    Get the available memory per node in GB.
-
-    Parameters
-    ----------
-    max_threads: float
-        If is_percentage is False, then number is interpreted as an absolute
-        number of threads.
-        Otherwise, it should be a number between 0 and 100 and is interpreted
-        as a percentage.
-    is_percentage: bool
-        A boolean indicating whether the parameter max_threads is to be interpreted
-        as a percentage of available system memory.
-    """
-    sys_n_threads = cpu_count(logical=True)
-    if is_percentage:
-        return (max_threads / 100.0) * sys_n_threads
-    else:
-        return min(max_threads, sys_n_threads)
-
-
-def extract_parameters(params_str, sep=";"):
-    """
-    Extract the named parameters from a string.
-
-    Example
-    --------
-    The function can be used as follows:
-
-    >>> extract_parameters("window_width=None; median_filt_shape=(3,3); padding_mode='wrap'")
-    ... {'window_width': None, 'median_filt_shape': (3, 3), 'padding_mode': 'wrap'}
-    """
-    if params_str in ("", None):
-        return {}
-    params_list = params_str.strip(sep).split(sep)
-    res = {}
-    for param_str in params_list:
-        param_name, param_val_str = param_str.strip().split("=")
-        param_name = param_name.strip()
-        param_val_str = param_val_str.strip()
-        param_val = literal_eval(param_val_str)
-        res[param_name] = param_val
-    return res
-
-
-def compact_parameters(params_dict, sep=";"):
-    """
-    Compact the parameters from a dict into a  string.
-
-    This is the inverse of extract_parameters. It can be used for example in tomwer to convert
-    parameters into a string, for example for cor_options, prior to calling a nabu method which
-    is expecting an argument to be in the form of a string containing options.
-
-    Example
-    --------
-    The function can be used as follows:
-
-    >>> compact_parameters( {"side":"near", "near_pos":300 } )
-    ... "side=near; nearpos= 300;"
-    """
-    if params_dict in ({}, None):
-        return ""
-
-    res = ""
-    for key, val in params_dict.items():
-        res = res + "{key} = {val} " + sep
-    return res
-
-
-def is_hdf5_extension(ext):
-    return ext.lower() in ["h5", "hdf5", "nx"]
-
-
-def get_quantities_and_units(string, sep=";"):
-    """
-    Return a dictionary with quantities as keys, and values in SI.
-
-    Example
-    -------
-    get_quantities_and_units("pixel_size = 1.2 um ; distance = 1 m")
-    Will return
-    {"pixel_size": 1.2e-6, "distance": 1}
-    """
-
-    result = {}
-    quantities = string.split(sep)
-    for quantity in quantities:
-        quantity_name, value_and_unit = quantity.split("=")
-        quantity_name = quantity_name.strip()
-        value_and_unit = value_and_unit.strip()
-        value, unit = value_and_unit.split()
-        val = float(value)
-        # Convert to SI
-        try:
-            # handle metrics
-            conversion_factor = MetricSystem.from_str(unit).value
-        except ValueError:
-            # handle energies
-            conversion_factor = EnergySI.from_str(unit).value / EnergySI.KILOELECTRONVOLT.value
-
-        result[quantity_name] = val * conversion_factor
-    return result