ewoksdata 2.2.1__tar.gz → 2.3.0rc2__tar.gz

{ewoksdata-2.2.1/src/ewoksdata.egg-info → ewoksdata-2.3.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ewoksdata
-Version: 2.2.1
+Version: 2.3.0rc2
 Summary: Ewoks tasks for data access
 Author-email: ESRF <dau-pydev@esrf.fr>
 License: # MIT License
@@ -40,6 +40,7 @@ Requires-Dist: h5py>=2.8
 Requires-Dist: silx>=1.1.0
 Requires-Dist: hdf5plugin
 Requires-Dist: blissdata>=0.3.4
+Requires-Dist: esrf-pathlib>=1.1.0
 Requires-Dist: redis
 Requires-Dist: redis!=5.3.0b1,!=5.3.0b3
 Requires-Dist: redis-om!=1.0.0b0; python_version < "3.9"
@@ -51,9 +52,7 @@ Requires-Dist: ewoksdata[online]; extra == "test"
 Requires-Dist: pytest>=7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ewoksdata[test]; extra == "dev"
-Requires-Dist: black>=25; extra == "dev"
-Requires-Dist: flake8>=4; extra == "dev"
-Requires-Dist: isort; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Provides-Extra: doc
 Requires-Dist: ewoksdata[test]; extra == "doc"
 Requires-Dist: sphinx>=4.5; extra == "doc"

{ewoksdata-2.2.1 → ewoksdata-2.3.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ewoksdata"
-version = "2.2.1"
+version = "2.3.0rc2"
 authors = [{ name = "ESRF", email = "dau-pydev@esrf.fr" }]
 description = "Ewoks tasks for data access"
 readme = { file = "README.md", content-type = "text/markdown" }
@@ -21,6 +21,7 @@ dependencies = [
     "silx >=1.1.0",
     "hdf5plugin",
     "blissdata >=0.3.4",
+    "esrf-pathlib >=1.1.0",
     "redis",                     # missing dependency in blissdata<1
     "redis !=5.3.0b1,!=5.3.0b3",
     "redis-om !=1.0.0b0;python_version < '3.9'",  # https://github.com/redis/redis-om-python/issues/693
@@ -44,9 +45,7 @@ test = [
 ]
 dev = [
     "ewoksdata[test]",
-    "black >=25",
-    "flake8 >=4",
-    "isort",
+    "ruff",
 ]
 doc = [
     "ewoksdata[test]",
@@ -64,6 +63,25 @@ where = ["src"]
 [tool.coverage.run]
 omit = ['*/tests/*']
 
-[tool.isort]
-profile = "black"
-force_single_line = "True"
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle errors
+    "F", # pyflakes
+    "I", # isort
+    "S", # flake8-bandit
+]
+ignore = [
+    "E501", # line too long (docstrings/comments are not wrapped by the formatter)
+]
+
+[tool.ruff.lint.per-file-ignores]
+"**/test_*.py" = ["S101"]
+"**/tests/**/conftest.py" = ["S101"]
+"ci/*.py" = ["S101"]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+known-first-party = ["ewoksdata"]

{ewoksdata-2.2.1 → ewoksdata-2.3.0rc2}/src/ewoksdata/data/blissdata/__init__.py

@@ -29,3 +29,6 @@ else:
 
     iter_bliss_scan_data_from_memory_slice = _not_supported_by_blissdata_version
     BUFFER_IN_MEMORY_DEFAULT = True
+
+from ._lima import LimaScan  # noqa F401
+from ._lima import find_lima_scans  # noqa F401

ewoksdata-2.3.0rc2/src/ewoksdata/data/blissdata/_lima.py

@@ -0,0 +1,447 @@
+import logging
+import re
+from dataclasses import dataclass
+from importlib.metadata import version
+from pathlib import Path
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import h5py
+import hdf5plugin  # noqa F401
+import numpy
+from blissdata.h5api.utils.lima import LimaDataset
+from esrf_pathlib import ESRFPath
+from packaging.version import Version
+from silx.io import h5py_utils
+
+_logger = logging.getLogger(__name__)
+
+_FORBIDDEN_CREATORS = ["lima"]
+_ALLOWED_CREATORS = ["bliss", "blissdata"]
+
+_ESRF_TEMPLATE_PROPOSAL = "raw_proposal_file"
+_ESRF_TEMPLATE_COLLECTION = "raw_collection_file"
+_ESRF_TEMPLATE_DATASET = "raw_dataset_file"
+_ALLOWED_ESRFPATH_TEMPLATES = [
+    _ESRF_TEMPLATE_PROPOSAL,
+    _ESRF_TEMPLATE_COLLECTION,
+    _ESRF_TEMPLATE_DATASET,
+]
+
+
+@dataclass
+class LimaScan:
+    """A single scan/detector entry with the information to access the data, to be used for ewoks tasks.
+
+    One instance is created by :func:`find_lima_scans` per scan/detector pair, and it holds
+    everything needed to read the frames, either through the Bliss master file (``url``) or
+    directly from the Lima data files (``lima_urls``, ``lima_url_template``).
+
+    :ivar filename: The dataset master file containing the scan, i.e. the file holding the
+        ``1.1``, ``2.1``, ``2.2``, ... groups. Normalized as an ESRF path (mount point stripped).
+    :ivar url: The url to access the data through the master file, in the format ``"filename::h5path"``,
+        the h5path being ``<scan_nb>.<subscan_nb>/measurement/<detector_name>``.
+    :ivar collection_name: The name of the collection/sample, taken from the file path.
+    :ivar dataset_name: The name of the dataset, taken from the file path.
+    :ivar scan_nb: The scan number, i.e. the part before the dot in the entry name.
+    :ivar subscan_nb: The subscan number, i.e. the part after the dot in the entry name (most of the time 1).
+    :ivar sample_id: The sample id parsed from the dataset name, ``None`` unless the dataset follows
+        the Daiquiri ``roi<sample_id>_<subsample_id>`` convention.
+    :ivar subsample_id: The subsample id parsed from the dataset name, ``None`` in the same conditions
+        as ``sample_id``.
+    :ivar detector_name: The name of the detector, as found in the measurement group.
+    :ivar data_shape: The shape of a single frame, i.e. the dataset shape without the frame dimension.
+    :ivar nb_frames: The number of frames in the scan, i.e. the first dimension of the dataset.
+    :ivar lima_urls: The urls of the Lima files holding the data, in the format ``"filename::h5path"``.
+        Missing files are skipped, so this list can be shorter than expected (or empty) for broken links.
+    :ivar lima_url_template: The template used to find the Lima files, ``None`` when they were found
+        through the virtual sources of the master file instead. See :func:`find_lima_scans`.
+    :ivar lima_url_template_args: The arguments to format ``lima_url_template``, ``None`` when there is
+        no template. See :func:`_get_lima_url_template_args`.
+    """
+
+    filename: str
+    url: str
+    collection_name: str
+    dataset_name: str
+    scan_nb: int
+    subscan_nb: int
+    sample_id: Optional[int]
+    subsample_id: Optional[int]
+    detector_name: str
+    data_shape: Tuple[int, ...]
+    nb_frames: int
+    lima_urls: List[str]
+    lima_url_template: Optional[str]
+    lima_url_template_args: Optional[dict]
+
+
+def _normalize_esrf_path(
+    filename: Optional[Union[str, Path, ESRFPath]], assert_exists: bool = True
+) -> ESRFPath:
+    """
+    This method allows to use bliss files using VISA paths and also avoids
+    the full path problem between mounting points.
+    """
+    if filename is not None:
+        filename = ESRFPath(filename).resolve().strip_mount_point()
+        if assert_exists and not filename.is_file():
+            raise FileNotFoundError(f"{filename} does not exist")
+    return filename
+
+
+def _get_lima_url_template_args(
+    scan_nb: int,
+    img_acq_device: str,
+    collection_name: str,
+    dataset_name: str,
+    scan_number_format: str = "%05d",
+) -> Dict[str, str]:
+    """
+    Lima url template args is a dictionary meant to format the lima_url_template string, once it is passed to blissdata.h5api.dynamic_hdf5.File.
+    For the blissdata API, it is useful during online data analysis from the .h5 file (only if the Lima files are already available, depending on number_frames_per_file)
+    For offline data analysis, it is useful in some cases:
+        - ID13 sometimes has used the Eiger hardware saving format (rare cases), hence the links from the master file are broken,
+            and the reading should be done through the dynamicfile API using lima_url_template and lima_url_template_args, to find the correct files and links to read the data.
+    For the rest of the cases, lima_url_template is not needed, as the master file has the data linked to the Lima files.
+    """
+    return {
+        "scan_nb": scan_number_format % int(scan_nb),
+        "img_acq_device": img_acq_device,
+        "collection_name": collection_name,
+        "dataset_name": dataset_name,
+    }
+
+
+def _parse_daiquiri_roi(
+    dataset_name: str,
+) -> Tuple[Optional[int], Optional[int]]:
+    """Return the ``(sample_id, subsample_id)`` encoded in a Daiquiri dataset name
+    (e.g. ``roi122006_140844``), or ``(None, None)`` when the name does not follow that convention.
+    """
+    match_roi = re.match(r"^roi(\d+)_(\d+)$", dataset_name)
+    if match_roi:
+        sample_id, subsample_id = int(match_roi.group(1)), int(match_roi.group(2))
+    else:
+        sample_id, subsample_id = None, None
+    return sample_id, subsample_id
+
+
+def _validate_bliss_file(h5_file: h5py.File) -> bool:
+    """Return True if the HDF5 root ``creator`` attribute is a 'bliss', 'blissdata', False otherwise."""
+    creator = h5_file.attrs.get("creator")
+    if isinstance(creator, bytes):
+        creator = creator.decode()
+    creator = creator.lower()
+    for forbidden in _FORBIDDEN_CREATORS:
+        if creator in forbidden:
+            _logger.error(f"File creator is '{creator}' which is not allowed.")
+            return False
+    for allowed in _ALLOWED_CREATORS:
+        if creator in allowed:
+            return True
+    _logger.error(
+        f"File creator is '{creator}' which is not recognized as a valid Bliss file creator."
+    )
+    return False
+
+
+def _discover_2d_detectors(measurement_group: h5py.Group) -> List[str]:
+    """Return the names of the 2D (Lima) detectors (3D datasets) in a measurement group."""
+    # Is there a better way to search for Lima devices?
+    return [dset for dset in measurement_group if measurement_group[dset].ndim == 3]
+
+
+def _get_lima_urls_from_virtual_sources(
+    dset: h5py.Dataset,
+) -> List[str]:
+    """Return the ``filename::h5path`` urls of the Lima files backing a virtual dataset.
+
+    The virtual sources of the Bliss master file are resolved relative to its directory.
+    Sources pointing to a missing file are skipped with a warning, so the returned list
+    may be shorter than the number of virtual sources (or empty for broken links).
+    """
+    urls_lima = []
+    for vs in dset.virtual_sources():
+        filename_lima = Path(dset.file.filename).parent / vs.file_name
+        if not filename_lima.is_file():
+            _logger.warning(
+                f"Lima file {filename_lima} does not exist. Virtual dataset may be broken."
+            )
+            continue
+        urls_lima.append(f"{str(_normalize_esrf_path(filename_lima))}::{vs.dset_name}")
+    return urls_lima
+
+
+def _get_lima_urls_from_template(
+    filename_dataset: str,
+    lima_url_template: str,
+    scan_nb: int,
+    detector: str,
+    collection_name: str,
+    dataset_name: str,
+    scan_number_format: Optional[str] = "%05d",
+) -> List[str]:
+    """Return the ``filename::h5path`` urls of the Lima files found with ``lima_url_template``.
+
+    Alternative to :func:`_get_lima_urls_from_virtual_sources` for the cases where the links of
+    the master file cannot be used (e.g. Eiger hardware saving): the files are searched on disk
+    with the blissdata API instead. Files that do not exist are skipped with a warning.
+
+    :param filename_dataset: The dataset master file; its directory is where the Lima files are searched.
+    :param lima_url_template: The ``"<file template>::<h5path>"`` template, see :func:`find_lima_scans`.
+    :param scan_nb: The scan number, formatted with ``scan_number_format``.
+    :param detector: The detector name, i.e. the ``{img_acq_device}`` placeholder of the template.
+    :param collection_name: The collection name, i.e. the ``{collection_name}`` placeholder of the template.
+    :param dataset_name: The dataset name, i.e. the ``{dataset_name}`` placeholder of the template.
+    :param scan_number_format: The format used for the scan number (default ``"%05d"``).
+    """
+    _, h5path_data = lima_url_template.split("::")
+    lima_url_template_args = _get_lima_url_template_args(
+        scan_nb=scan_nb,
+        img_acq_device=detector,
+        collection_name=collection_name,
+        dataset_name=dataset_name,
+        scan_number_format=scan_number_format,
+    )
+    limadataset_params = {
+        "name": f"/{scan_nb}.1/instrument/{detector}/data",  # this is dummy parameter
+        "dirname": str(Path(filename_dataset).parent),
+        "url_template": lima_url_template,
+        "url_template_args": lima_url_template_args,
+    }
+    if Version(version("blissdata")) < Version("1.1.0"):
+        for p in ("url_template", "url_template_args"):
+            limadataset_params.pop(p)
+
+    limadataset = LimaDataset(**limadataset_params)
+    limadataset.search()
+    urls_lima = []
+    for lima_file in limadataset._files:
+        if not Path(lima_file).is_file():
+            _logger.warning(
+                f"Lima file {lima_file} does not exist. Check the lima_url_template and lima_url_template_args, the Lima files may not be found."
+            )
+            continue
+        urls_lima.append(f"{_normalize_esrf_path(lima_file)}::{h5path_data}")
+    return urls_lima
+
+
+def _validate_lima_urls(lima_urls: List[str]) -> None:
+    """Check that the data path is an accessible dataset in each Lima file."""
+    for lima_url in lima_urls:
+        filename_lima, h5path_lima = lima_url.split("::")
+        with h5py_utils.File(filename=filename_lima, mode="r") as f:
+            if h5path_lima not in f:
+                raise KeyError(
+                    f"Validation of Lima files failed: {h5path_lima} not found in {filename_lima}"
+                )
+            if not isinstance(f[h5path_lima], h5py.Dataset):
+                raise TypeError(
+                    f"Validation of Lima files failed: {h5path_lima} is not a dataset in {filename_lima}"
+                )
+
+
+def _validate_virtual_datasets(
+    dataset: h5py.Dataset,
+    nb_frames_to_validate: int = 10,
+) -> None:
+    """Check that the virtual dataset is readable and not all zeros (broken links)."""
+    try:
+        dataset_from_bliss_file = dataset[0:nb_frames_to_validate]
+    except OSError:
+        raise OSError(
+            f"Validation of Virtual datasets failed: could not read data from the dataset {dataset.name}. This may be due to broken links to Lima files."
+        )
+    if numpy.array_equal(
+        dataset_from_bliss_file, numpy.zeros_like(dataset_from_bliss_file)
+    ):
+        raise ValueError(
+            f"Validation of Virtual datasets failed: data in {dataset.name} is all zeros, which points to a broken virtual dataset (broken links to Lima files)."
+        )
+
+
+def _parse_scansubscan_entry(h5path_entry: str) -> Tuple[int, int]:
+    """Return the ``(scan_nb, subscan_nb)`` integers of a Bliss root entry name (e.g. ``"2.1"``)."""
+    pattern_scan_subscan_entry = r"^(\d+)\.(\d+)$"
+    match_scan_entry = re.match(pattern_scan_subscan_entry, h5path_entry)
+    scan_nb = int(match_scan_entry.group(1))
+    subscan_nb = int(match_scan_entry.group(2))
+    return scan_nb, subscan_nb
+
+
+def _find_bliss_dataset_files(
+    *args: List[Union[str, Path, ESRFPath]],
+) -> List[ESRFPath]:
+    """Return the sorted, deduplicated dataset master files described by ``args``.
+
+    Both files and directories are accepted: a file is taken as-is, while a directory is expanded
+    into the ``*.h5`` files it directly contains (not recursive). Anything that is neither an
+    existing file nor an existing directory is ignored.
+
+    Each resulting filename is normalized to an :class:`ESRFPath` and expanded according to its
+    template: a proposal file yields all dataset files of all its collections, a collection file
+    yields all dataset files of that collection, and a dataset file yields itself. Filenames
+    matching none of :data:`ALLOWED_ESRFPATH_TEMPLATES` are skipped with an error log.
+    """
+    bliss_filenames = []
+    for item in args:
+        esrf_item = ESRFPath(item)
+        if esrf_item.is_file():
+            bliss_filenames.append(esrf_item)
+        elif esrf_item.is_dir():
+            bliss_filenames += sorted(esrf_item.glob("*.h5"))
+
+    filenames_datasets = []
+    for bliss_filename in bliss_filenames:
+        esrf_filename = _normalize_esrf_path(filename=bliss_filename)
+        if not esrf_filename:
+            continue
+
+        if esrf_filename.template_name not in _ALLOWED_ESRFPATH_TEMPLATES:
+            _logger.error(
+                f"{str(esrf_filename)} is a {esrf_filename.template_name} files are not allowed. Only {_ALLOWED_ESRFPATH_TEMPLATES}"
+            )
+            continue
+        if esrf_filename.template_name == _ESRF_TEMPLATE_PROPOSAL:
+            filenames_datasets += list(
+                esrf_filename.parent.replace_fields(collection="*", dataset="*").glob()
+            )
+        elif esrf_filename.template_name == _ESRF_TEMPLATE_COLLECTION:
+            filenames_datasets += list(
+                esrf_filename.parent.replace_fields(dataset="*").glob()
+            )
+        elif esrf_filename.template_name == _ESRF_TEMPLATE_DATASET:
+            filenames_datasets += [esrf_filename]
+        else:
+            _logger.debug("Unsupported HDF5 file name %r", esrf_filename)
+    return sorted(set(filenames_datasets))
+
+
+def find_lima_scans(
+    bliss_filenames: List[str],
+    detectors: Optional[List[str]] = None,
+    scans: Optional[List[int]] = None,
+    subscans: Optional[List[int]] = None,
+    lima_url_template: Optional[str] = None,
+    scan_number_format: Optional[str] = "%05d",
+    validate_data_lima_files: bool = False,
+    validate_data_virtual_datasets: bool = False,
+    nb_frames_to_validate: int = 10,
+) -> List[LimaScan]:
+    """
+    Access the given Bliss .h5 files and find the scans matching the requested scan and subscan numbers and detectors.
+
+    :param bliss_filenames: A list of HDF5 filenames (e.g. ``path/to/file.h5``), written by NexusWriter,
+            and/or directories containing such files (e.g. ``path/to/dir``, expanded to the ``*.h5``
+            files it directly contains, not recursive).
+            A proposal, collection or dataset file is accepted; anything else is skipped with an error log.
+    :param detectors: A list of detector names to filter the scans (e.g. ``["detector1", "detector2"]``). If None, all 2D detectors are considered.
+    :param scans: A list of scan numbers to filter the scans (e.g. ``[1, 2, 3]``). If None, all scans are considered.
+    :param subscans: A list of subscan numbers to filter the scans (e.g. ``[1, 2]``). If None, all subscans are considered.
+    :param lima_url_template: A template to find the data files. To be used if the data files don't follow the Lima format (e.g. Eiger hardware saving)
+            the template must be a format string with the following placeholders:
+                - {dirname}: the directory of the dataset master file
+                - {scan_nb}: the scan number integer, which will be formatted according to the parameter scan_number_format
+                - {img_acq_device}: the name of the detector
+                - {collection_name}: the collection name
+                - {dataset_name}: the dataset name
+            example: "{dirname}/scan{scan_nb}/{img_acq_device}/{collection_name}_{dataset_name}_{scan_nb}_data_{{file_index}}.h5::/entry_0000/measurement/data"
+    :param scan_number_format: The format to use to find the scan number in the lima_url_template (default is "%05d" for 5 digits with leading zeros)
+    :param validate_data_lima_files: Whether to validate if the data of the Lima files are accesible
+    :param validate_data_virtual_datasets: Whether to validate if the data of the Virtual datasets are accesible and not broken (e.g. all zeros).
+        The number of data frames in memory is controlled by `nb_frames_to_validate`
+    :param nb_frames_to_validate: The number of frames to load in memory for the validation of virtual datasets.
+
+    :raises KeyError: When ``validate_data_lima_files`` is enabled and the data path is missing in a Lima file.
+    :raises TypeError: When ``validate_data_lima_files`` is enabled and the data path is not a dataset in a Lima file.
+    :raises OSError: When ``validate_data_virtual_datasets`` is enabled and a virtual dataset cannot be read (broken links).
+    :raises ValueError: When ``validate_data_virtual_datasets`` is enabled and a virtual dataset only contains zeros (broken links).
+
+    :return: One :class:`LimaScan` object per matching scan/detector pair (empty list when nothing
+        matches), see :class:`LimaScan` for the description of each field.
+    """
+    lima_scans = []
+    filenames_datasets = _find_bliss_dataset_files(*bliss_filenames)
+    for filename_dataset in filenames_datasets:
+        with h5py_utils.File(filename=filename_dataset, mode="r") as h5_bliss_root:
+            if not _validate_bliss_file(h5_bliss_root):
+                continue
+
+            for scan_entry_path in h5_bliss_root:
+                scan_nb, subscan_nb = _parse_scansubscan_entry(scan_entry_path)
+                if scans and scan_nb not in scans:
+                    continue
+                if subscans and subscan_nb not in subscans:
+                    continue
+                if "measurement" not in h5_bliss_root[scan_entry_path]:
+                    continue
+
+                # Only for Daiquiri collected datasets
+                roi_id, subsample_id = _parse_daiquiri_roi(filename_dataset.dataset)
+
+                measurement_group = h5_bliss_root[f"{scan_entry_path}/measurement"]
+                if detectors:
+                    detectors = [d for d in detectors if d in measurement_group]
+                else:
+                    detectors = _discover_2d_detectors(measurement_group)
+
+                for detector in detectors:
+                    # Data from virtual datasets
+                    if validate_data_virtual_datasets:
+                        _validate_virtual_datasets(
+                            dataset=measurement_group[detector],
+                            nb_frames_to_validate=nb_frames_to_validate,
+                        )
+
+                    # Search the lima files
+                    if lima_url_template:
+                        lima_urls = _get_lima_urls_from_template(
+                            filename_dataset=str(filename_dataset),
+                            lima_url_template=lima_url_template,
+                            scan_nb=scan_nb,
+                            detector=detector,
+                            collection_name=filename_dataset.collection,
+                            dataset_name=filename_dataset.dataset,
+                            scan_number_format=scan_number_format,
+                        )
+                    else:
+                        lima_urls = _get_lima_urls_from_virtual_sources(
+                            measurement_group[detector]
+                        )
+
+                    if validate_data_lima_files:
+                        _validate_lima_urls(lima_urls)
+
+                    lima_scans.append(
+                        LimaScan(
+                            filename=str(filename_dataset),
+                            url=f"{filename_dataset}::{scan_nb}.{subscan_nb}/measurement/{detector}",
+                            collection_name=filename_dataset.collection,
+                            dataset_name=filename_dataset.dataset,
+                            scan_nb=scan_nb,
+                            subscan_nb=subscan_nb,
+                            sample_id=roi_id,
+                            subsample_id=subsample_id,
+                            detector_name=detector,
+                            data_shape=measurement_group[detector].shape[1:],
+                            nb_frames=measurement_group[detector].shape[0],
+                            lima_urls=lima_urls,
+                            lima_url_template=lima_url_template,
+                            lima_url_template_args=(
+                                _get_lima_url_template_args(
+                                    scan_nb=scan_nb,
+                                    img_acq_device=detector,
+                                    collection_name=filename_dataset.collection,
+                                    dataset_name=filename_dataset.dataset,
+                                    scan_number_format=scan_number_format,
+                                )
+                                if lima_url_template
+                                else None
+                            ),
+                        )
+                    )
+    return lima_scans

{ewoksdata-2.2.1 → ewoksdata-2.3.0rc2}/src/ewoksdata/data/blissdata/blissdatav1.py

@@ -190,7 +190,6 @@ def iter_bliss_scan_data_from_memory_slice(
 
     restart_buffer = time.perf_counter()
     while stream_on:
-
         # While loop will stop unless one single stream is successfully sliced
         stream_on = False
 
@@ -245,7 +244,6 @@ def iter_bliss_scan_data_from_memory_slice(
                     incoming_buffers[stream_name] = []
 
         if not stream_on or ((time.perf_counter() - restart_buffer) > yield_timeout):
-
             frames_to_yield = min(
                 [len(value) for value in non_yielded_buffers.values()]
             )

{ewoksdata-2.2.1 → ewoksdata-2.3.0rc2}/src/ewoksdata/data/blissdata/blissdatav2.py

@@ -271,7 +271,6 @@ def iter_bliss_scan_data_from_memory_slice(
 
     restart_buffer = time.perf_counter()
     while stream_on:
-
         # While loop will stop unless one single stream is successfully sliced
         stream_on = False
 
@@ -326,7 +325,6 @@ def iter_bliss_scan_data_from_memory_slice(
                     incoming_buffers[stream_name] = []
 
         if not stream_on or ((time.perf_counter() - restart_buffer) > yield_timeout):
-
             frames_to_yield = min(
                 [len(value) for value in non_yielded_buffers.values()]
             )

{ewoksdata-2.2.1 → ewoksdata-2.3.0rc2}/src/ewoksdata/data/hdf5/config.py

@@ -55,9 +55,10 @@ def guess_data_shape(
     detector_shape = tuple(n if n else DEFAULT_SCAN_DIM_SIZE for n in detector_shape)
     data_shape = scan_shape + detector_shape
     if max_shape:
-        assert len(max_shape) == len(
-            data_shape
-        ), "HDF5 dataset shape must have the same dimensions as maxshape"
+        if len(max_shape) != len(data_shape):
+            raise ValueError(
+                "HDF5 dataset shape must have the same dimensions as maxshape"
+            )
         data_shape = tuple(
             n1 if not n2 else max(n1, n2) for n1, n2 in zip(data_shape, max_shape)
         )