ewoksdata 2.3.0rc4__tar.gz → 2.3.0rc5__tar.gz

{ewoksdata-2.3.0rc4/src/ewoksdata.egg-info → ewoksdata-2.3.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ewoksdata
-Version: 2.3.0rc4
+Version: 2.3.0rc5
 Summary: Ewoks tasks for data access
 Author-email: ESRF <dau-pydev@esrf.fr>
 License: # MIT License
@@ -49,7 +49,9 @@ Provides-Extra: online
 Requires-Dist: blissdata[lima2,tango]; extra == "online"
 Provides-Extra: test
 Requires-Dist: ewoksdata[online]; extra == "test"
-Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest>=7; python_full_version != "3.10.0" and extra == "test"
+Requires-Dist: pytest<9.2,>=7; python_full_version == "3.10.0" and extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ewoksdata[test]; extra == "dev"
 Requires-Dist: ruff; extra == "dev"

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ewoksdata"
-version = "2.3.0rc4"
+version = "2.3.0rc5"
 authors = [{ name = "ESRF", email = "dau-pydev@esrf.fr" }]
 description = "Ewoks tasks for data access"
 readme = { file = "README.md", content-type = "text/markdown" }
@@ -41,7 +41,9 @@ online = [
 ]
 test = [
     "ewoksdata[online]",
-    "pytest >=7",
+    "pytest >=7; python_full_version != '3.10.0'",
+    "pytest >=7,<9.2; python_full_version == '3.10.0'",  # pytest 9.2 needs bpo-44649 fixed
+    "pytest-timeout",
 ]
 dev = [
     "ewoksdata[test]",
@@ -63,6 +65,10 @@ where = ["src"]
 [tool.coverage.run]
 omit = ['*/tests/*']
 
+[tool.pytest.ini_options]
+timeout = 120
+timeout_method = "thread"
+
 [tool.ruff]
 line-length = 88
 

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/data/blissdata/__init__.py

@@ -1,3 +1,4 @@
+import logging
 from importlib.metadata import version
 
 from packaging.version import Version
@@ -7,9 +8,26 @@ def _not_supported_by_blissdata_version(*_, **kw):
     raise RuntimeError(f"Not supported by blissdata {_BLISSDATA_VERSION}")
 
 
+def _warn_redis_socket_timeout() -> None:
+    """Log a warning when the installed redis and blissdata versions make blocking redis calls time out."""
+    redis_version = Version(version("redis"))
+    blissdata_affected = Version("1") <= _BLISSDATA_VERSION < Version("2.4.6")
+    if blissdata_affected and redis_version >= Version("8"):
+        _logger.warning(
+            "redis %s with blissdata %s: blocking redis calls time out after 5 seconds. "
+            "Use redis<8 or blissdata>=2.4.6.",
+            redis_version,
+            _BLISSDATA_VERSION,
+        )
+
+
+_logger = logging.getLogger(__name__)
+
+
 from blissdata.h5api import dynamic_hdf5  # noqa F401
 
 _BLISSDATA_VERSION = Version(version("blissdata"))
+_warn_redis_socket_timeout()
 
 if _BLISSDATA_VERSION >= Version("2.0.0rc1"):
     from .blissdatav2 import iter_bliss_scan_data_from_memory  # noqa F401

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/data/blissdata/blissdatav2.py

@@ -95,16 +95,13 @@ def iter_bliss_scan_data_from_memory(
             for data_buffer in data_buffers.values():
                 data_buffer.buffer_in_memory()
 
-        while True:
-            try:
-                ctr_values = [
-                    next(data_buffer) for data_buffer in data_buffers.values()
-                ]
-            except StopIteration:
-                # One of the buffers ran out of data
-                break
-
-            yield dict(zip(ctr_names, ctr_values))
+        # Only consume points available for all counters to keep them aligned
+        nyield = min(data_buffer.length_left for data_buffer in data_buffers.values())
+        for _ in range(nyield):
+            yield {
+                ctr_name: next(data_buffer)
+                for ctr_name, data_buffer in data_buffers.items()
+            }
 
 
 class _DataBuffer(Iterator):
@@ -152,6 +149,7 @@ class _DataBuffer(Iterator):
     def __next__(self):
         """Return next scan data point for this counter."""
         if self._buffer:
+            self._total_yielded += 1
             return self._buffer.pop(0)
 
         if len(self._views) == 0:

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/data/hdf5/mirror.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import posixpath
 from typing import Any
 from typing import NamedTuple
 from typing import Optional
@@ -234,8 +235,8 @@ def _mirror(
     # Whether opening `original` would mean reading it from a file other
     # than the one being mirrored: never allowed unless `allow_cross_file`,
     # regardless of what `expand`/`recursive` ask for (see `traverse` below).
-    crosses_file = (
-        os.path.abspath(_get_hdf5_filename(original.file)) != home_original.file_path()
+    crosses_file = not _same_file(
+        _get_hdf5_filename(original.file), home_original.file_path()
     )
 
     # Open `original` as a group instead of mirroring it as a single link or
@@ -554,7 +555,7 @@ def _relative_to_home_original(absolute_path: str, home_original: DataUrl) -> st
     """HDF5 path of :code:`absolute_path` relative to :code:`home_original`'s path,
     empty for :code:`home_original` itself.
     """
-    relative_path = os.path.relpath(absolute_path, home_original.data_path())
+    relative_path = posixpath.relpath(absolute_path, home_original.data_path())
     if relative_path == ".":
         return ""
     return relative_path
@@ -573,7 +574,7 @@ def _soft_link_in_scope(
     """Does the soft link target :code:`target_path` refer to a path within
     :code:`home_original`'s path?
     """
-    if os.path.abspath(_get_hdf5_filename(parent.file)) != home_original.file_path():
+    if not _same_file(_get_hdf5_filename(parent.file), home_original.file_path()):
         return False
     return _in_scope(target_path, home_original.data_path())
 
@@ -668,7 +669,7 @@ def _hdf5_link_object(
         )
 
     # Internal link
-    if os.path.normpath(abs_parent_filename) == os.path.normpath(abs_target_filename):
+    if _same_file(abs_parent_filename, abs_target_filename):
         link_full_name = _normalize_hdf5_item_name(parent_name, link_name)
         target_name = _normalize_hdf5_item_name(target_name)
         if link_full_name == target_name:
@@ -676,7 +677,7 @@ def _hdf5_link_object(
             return None
         if not relative:
             return h5py.SoftLink(target_name)
-        rel_target_name = os.path.relpath(target_name, parent_name)
+        rel_target_name = posixpath.relpath(target_name, parent_name)
         if ".." in rel_target_name:
             # Internal links upwards are not supported
             return h5py.SoftLink(target_name)
@@ -696,9 +697,9 @@ def _mirrors_itself(
     parent: GroupType, name: str, original: Union[DatasetType, GroupType]
 ) -> bool:
     """Is :code:`name` in :code:`parent` the HDF5 item :code:`original` itself?"""
-    parent_filename = os.path.abspath(_get_hdf5_filename(parent.file))
-    original_filename = os.path.abspath(_get_hdf5_filename(original.file))
-    if os.path.normpath(parent_filename) != os.path.normpath(original_filename):
+    if not _same_file(
+        _get_hdf5_filename(parent.file), _get_hdf5_filename(original.file)
+    ):
         return False
     return _normalize_hdf5_item_name(parent.name, name) == _normalize_hdf5_item_name(
         original.name
@@ -812,3 +813,13 @@ def _get_hdf5_filename(file_obj: FileType) -> str:
     except AttributeError:
         pass
     raise AttributeError(f"cannot determine the HDF5 filename of {file_obj!r}")
+
+
+def _same_file(filename1: str, filename2: str) -> bool:
+    """Do both filenames refer to the same file?"""
+    return _normalize_filename(filename1) == _normalize_filename(filename2)
+
+
+def _normalize_filename(filename: str) -> str:
+    # On Windows the same file can be spelled with `\` or `/` and in any case
+    return os.path.normcase(os.path.normpath(os.path.abspath(filename)))

ewoksdata-2.3.0rc5/src/ewoksdata/data/nfs.py

@@ -0,0 +1,64 @@
+import os
+from typing import List
+from typing import Set
+from typing import Union
+
+
+def nfs_cache_refresh(*paths: Union[str, os.PathLike]) -> None:
+    """Refresh the NFS client cache of the paths so their latest state is visible.
+
+    Paths that do not exist (yet) refresh their closest existing ancestor directory.
+    """
+    refreshed: Set[str] = set()
+    for path in paths:
+        _refresh_path(os.path.abspath(path), refreshed)
+
+
+def _refresh_path(path: str, refreshed: Set[str]) -> None:
+    missing: List[str] = []
+    dirname = path
+    while not os.path.isdir(dirname):
+        missing.append(dirname)
+        parent = os.path.dirname(dirname)
+        if parent == dirname:
+            return
+        dirname = parent
+
+    # Listing a directory can reveal children that were cached as non-existing
+    while True:
+        _refresh_directory(dirname, refreshed)
+        if not missing:
+            return
+        child = missing.pop()
+        if os.path.isdir(child):
+            dirname = child
+        else:
+            if os.path.exists(child):
+                _refresh_file(child)
+            return
+
+
+def _refresh_directory(dirname: str, refreshed: Set[str]) -> None:
+    if dirname in refreshed:
+        return
+    refreshed.add(dirname)
+    try:
+        with os.scandir(dirname) as entries:
+            for entry in entries:
+                try:
+                    _ = (
+                        entry.stat()
+                    )  # This forces a fresh stat call, similar to "ls -l"
+                except OSError:
+                    pass
+    except OSError:
+        pass
+
+
+def _refresh_file(filename: str) -> None:
+    # Close-to-open consistency: opening revalidates the cached attributes
+    try:
+        fd = os.open(filename, os.O_RDONLY)
+    except OSError:
+        return
+    os.close(fd)

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/tests/integration/conftest.py

@@ -42,6 +42,28 @@ def requires_blissdata_v1() -> None:
         pytest.skip("requires blissdata>=1")
 
 
+@pytest.fixture(scope="session")
+def requires_blissdata_v2() -> None:
+    if Version(version("blissdata")) < Version("2.0.0rc1"):
+        pytest.skip("requires blissdata>=2.0.0rc1")
+
+
+@pytest.fixture(scope="session")
+def data_store(requires_blissdata_v2):
+    """Blissdata data store, skip when Redis is not available."""
+    if not os.environ.get("BEACON_HOST"):
+        pytest.skip("BEACON_HOST is not set")
+
+    # Deferred: these modules do not exist in older blissdata versions
+    from blissdata.beacon.data import BeaconData
+    from blissdata.redis_engine.store import DataStore
+
+    try:
+        return DataStore(BeaconData().get_redis_data_db())
+    except Exception as ex:
+        pytest.skip(f"Cannot connect to Redis: {ex}")
+
+
 @pytest.fixture(scope="session")
 def demo_session():
     """Activate the Bliss demo session, skip when it is not available."""

ewoksdata-2.3.0rc5/src/ewoksdata/tests/integration/test_iter_memory.py

@@ -0,0 +1,24 @@
+from ...data.blissdata import iter_bliss_scan_data_from_memory
+from ...data.blissdata import iter_bliss_scan_data_from_memory_slice
+
+LIMA_NAMES = ["difflab6"]
+COUNTER_NAMES = ["diode1"]
+
+
+def test_iter_memory(scan_key):
+    n = 0
+    for data in iter_bliss_scan_data_from_memory(scan_key, LIMA_NAMES, COUNTER_NAMES):
+        assert set(data) == {"difflab6", "diode1"}
+        assert data["difflab6"].ndim == 2
+        n += 1
+    assert n == 10
+
+
+def test_iter_slice_memory(scan_key, requires_blissdata_v1):
+    n = 0
+    for data in iter_bliss_scan_data_from_memory_slice(
+        scan_key, LIMA_NAMES, COUNTER_NAMES, slice_range=(3, 5)
+    ):
+        assert set(data) == {"difflab6", "diode1"}
+        n += 1
+    assert n == 2

ewoksdata-2.3.0rc5/src/ewoksdata/tests/integration/test_iter_memory_live.py

@@ -0,0 +1,170 @@
+import logging
+import threading
+from importlib.metadata import version
+from typing import Any
+from typing import Dict
+from typing import Iterator
+from typing import List
+
+import numpy
+import pytest
+from packaging.version import Version
+
+if Version(version("blissdata")) < Version("2.0.0rc1"):
+    pytest.skip("requires blissdata >= 2.0.0rc1", allow_module_level=True)
+
+from blissdata.redis_engine.scan import Scan
+
+if Version(version("blissdata")) >= Version("2.3.0"):
+    from blissdata.streams import BaseStream
+    from blissdata.streams.default import Stream
+else:
+    from blissdata.streams.base import BaseStream
+    from blissdata.streams.base import Stream
+
+from ...data.blissdata import blissdatav2
+
+
+@pytest.mark.parametrize(
+    "slow_stream,fast_stream", [("first", "second"), ("second", "first")]
+)
+def test_iter_memory_streams_out_of_sync(data_store, caplog, slow_stream, fast_stream):
+    """One stream receives its data slower than the other one while the scan
+    data is being read: data points must not be lost nor misaligned."""
+    npoints = 12
+    stream_data = {
+        "first": numpy.arange(npoints),
+        "second": numpy.arange(1000, 1000 + npoints),
+    }
+    counter_names = list(stream_data)
+    timeout = 30  # seconds
+
+    # Each feeding round sends 3 points to the fast stream, then 2 to the slow one
+    feed_order = [fast_stream, slow_stream]
+    chunk_sizes = {fast_stream: 3, slow_stream: 2}
+
+    # Points in both streams after each feeding round are those of the slow stream
+    slow_chunk = chunk_sizes[slow_stream]
+    npoints_per_round = list(range(slow_chunk, npoints + 1, slow_chunk))
+
+    scan_identity = {
+        "name": "streams_out_of_sync",
+        "number": 1,
+        "data_policy": "no_policy",
+    }
+    scan = data_store.create_scan(scan_identity)
+    reader = _ScanReader(scan.key, counter_names=counter_names, timeout=timeout)
+    with caplog.at_level(logging.INFO, logger=blissdatav2.logger.name):
+        try:
+            streams = _create_streams(scan, stream_data)
+            scan.prepare()
+            scan.start()
+            reader.start()
+            for npoints_sent in _feed_streams(
+                streams,
+                stream_data,
+                feed_order=feed_order,
+                chunk_sizes=chunk_sizes,
+                npoints_per_round=npoints_per_round,
+            ):
+                reader.wait_for_points(npoints_sent)
+            scan.stop()  # Seals the streams: the reader gets the end of the streams
+            reader.join(timeout=timeout)
+        finally:
+            # Seals the streams if not done yet so the reader never blocks forever
+            scan.close()
+
+    # The reader reached the end of the streams without errors
+    assert not reader.is_alive(), f"Reader not done after {timeout} seconds"
+    if reader.errors:
+        raise reader.errors[0]
+
+    # Every point was read once, with the values of both streams aligned
+    expected_data = [
+        {name: data[i] for name, data in stream_data.items()} for i in range(npoints)
+    ]
+    assert reader.data == expected_data
+
+    # The iterator logged that it yielded every point of each stream, with no warnings
+    expected_progress = "\n".join(
+        f"{name}: {npoints}/{npoints}" for name in counter_names
+    )
+    assert expected_progress in caplog.text
+    assert not [r for r in caplog.records if r.levelname == "WARNING"]
+
+
+class _ScanReader(threading.Thread):
+    """Reads scan data from memory in a background thread."""
+
+    def __init__(self, scan_key: str, counter_names: List[str], timeout: float) -> None:
+        super().__init__(daemon=True)
+        self._scan_key = scan_key
+        self._counter_names = counter_names
+        self._timeout = timeout
+        self._data_added = threading.Condition()
+        self._finished = False
+        self.data: List[Dict[str, Any]] = []
+        self.errors: List[BaseException] = []
+
+    def run(self) -> None:
+        try:
+            for point in blissdatav2.iter_bliss_scan_data_from_memory(
+                self._scan_key, counter_names=self._counter_names
+            ):
+                with self._data_added:
+                    self.data.append(point)
+                    self._data_added.notify_all()
+        except BaseException as ex:
+            self.errors.append(ex)
+        finally:
+            with self._data_added:
+                self._finished = True
+                self._data_added.notify_all()
+
+    def wait_for_points(self, npoints: int) -> None:
+        """Wait until `npoints` points were read, or reading stopped."""
+
+        def points_read() -> bool:
+            return len(self.data) >= npoints or self._finished
+
+        with self._data_added:
+            done = self._data_added.wait_for(points_read, timeout=self._timeout)
+        assert done, f"Read {len(self.data)} of {npoints} points"
+
+
+def _create_streams(
+    scan: Scan, stream_data: Dict[str, numpy.ndarray]
+) -> Dict[str, BaseStream]:
+    """Create one stream per counter. The iterator finds a counter by the last
+    part of the stream name."""
+    return {
+        name: scan.create_stream(Stream.make_definition(f"sim:{name}", data.dtype.type))
+        for name, data in stream_data.items()
+    }
+
+
+def _feed_streams(
+    streams: Dict[str, BaseStream],
+    stream_data: Dict[str, numpy.ndarray],
+    feed_order: List[str],
+    chunk_sizes: Dict[str, int],
+    npoints_per_round: List[int],
+) -> Iterator[int]:
+    """Each round sends the next chunk to each stream in `feed_order`, then yields
+    the number of points the reader can read after that round."""
+    positions = {name: 0 for name in feed_order}
+    for npoints in npoints_per_round:
+        for name in feed_order:
+            start = positions[name]
+            stop = start + chunk_sizes[name]
+            chunk = stream_data[name][start:stop]
+            if len(chunk):
+                streams[name].send(chunk)
+                streams[name].join()
+            positions[name] = stop
+        yield npoints
+
+    not_sent = [name for name in feed_order if positions[name] < len(stream_data[name])]
+    assert not not_sent, (
+        f"Data not sent after {len(npoints_per_round)} rounds: {not_sent}"
+    )

ewoksdata-2.3.0rc4/src/ewoksdata/tests/integration/test_blissdata.py → ewoksdata-2.3.0rc5/src/ewoksdata/tests/integration/test_last_lima_image.py

@@ -2,32 +2,8 @@ from importlib.metadata import version
 
 from packaging.version import Version
 
-from ...data.blissdata import iter_bliss_scan_data_from_memory
-from ...data.blissdata import iter_bliss_scan_data_from_memory_slice
 from ...data.blissdata import last_lima_image
 
-LIMA_NAMES = ["difflab6"]
-COUNTER_NAMES = ["diode1"]
-
-
-def test_iter_memory(scan_key):
-    n = 0
-    for data in iter_bliss_scan_data_from_memory(scan_key, LIMA_NAMES, COUNTER_NAMES):
-        assert set(data) == {"difflab6", "diode1"}
-        assert data["difflab6"].ndim == 2
-        n += 1
-    assert n == 10
-
-
-def test_iter_slice_memory(scan_key, requires_blissdata_v1):
-    n = 0
-    for data in iter_bliss_scan_data_from_memory_slice(
-        scan_key, LIMA_NAMES, COUNTER_NAMES, slice_range=(3, 5)
-    ):
-        assert set(data) == {"difflab6", "diode1"}
-        n += 1
-    assert n == 2
-
 
 def test_last_lima_image(scan_key):
     blissdata_version = Version(version("blissdata"))

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/tests/unit/test_dataset_writer.py

@@ -1,5 +1,6 @@
 import itertools
 import multiprocessing
+import sys
 import time
 
 import h5py
@@ -182,6 +183,12 @@ def test_indexed_stack_dataset_writer(
     numpy.testing.assert_allclose(data, expected)
 
 
+# HDF5 locks with LockFileEx on Windows, which blocks reads from other processes:
+# https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-lockfileex
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="non-locking HDF5 readers cannot read a file locked by a writer",
+)
 def test_concurrent_reader(tmp_path):
     npoints = 50
     hdf5_filename = str(tmp_path / "test.h5")
@@ -206,27 +213,24 @@ def test_concurrent_reader(tmp_path):
         ),
     )
     reader_process.start()
-
-    assert start_event.wait(timeout=10)
-
-    # Run write loop
     try:
+        assert start_event.wait(timeout=30), "Reader did not start within the timeout."
+
         _write_hdf5_file(hdf5_filename, dataset_name, npoints, write_timestamps, nread)
-    except Exception:
-        reader_process.terminate()
-        raise
-
-    # Do not rely on the exit code: with gevent monkey-patching (bliss
-    # integration tests in the same session), once any subprocess was started,
-    # gevent collects the exit code of every child process that terminates.
-    # The exit code of the reader is then no longer available to
-    # multiprocessing, so `reader_process.exitcode` stays `None`.
-    try:
-        assert done_event.wait(timeout=20), "Reader did not finish within the timeout."
+
+        # Do not rely on the exit code: with gevent monkey-patching (bliss
+        # integration tests in the same session), once any subprocess was started,
+        # gevent collects the exit code of every child process that terminates.
+        # The exit code of the reader is then no longer available to
+        # multiprocessing, so `reader_process.exitcode` stays `None`.
+        assert done_event.wait(timeout=30), "Reader did not finish within the timeout."
     finally:
+        # Always reap the reader: a leaked process on the CI host keeps
+        # running and can disrupt unrelated jobs sharing the same machine.
         reader_process.join(timeout=5)
         if reader_process.is_alive():
             reader_process.terminate()
+            reader_process.join(timeout=5)
 
     read_events = _load_events(read_timestamps)
     write_events = _load_events(write_timestamps)

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/tests/unit/test_mirror_hdf5.py

@@ -1,6 +1,7 @@
 import contextlib
 import gc
 import logging
+import sys
 from pathlib import Path
 from typing import Generator
 from typing import Type
@@ -11,6 +12,7 @@ import numpy
 import pytest
 
 from ...data.blissdata import dynamic_hdf5
+from ...data.hdf5.mirror import _same_file
 from ...data.hdf5.mirror import mirror_hdf5_content
 
 
@@ -1206,3 +1208,17 @@ def _get_hdf5_structure(item: Union[h5py.Group, h5py.Dataset]) -> dict:
         content[name] = subcontent
 
     return content
+
+
+@pytest.mark.parametrize("spelling", ["relative_parts", "separators", "case"])
+def test_same_file(tmp_path, spelling):
+    filename = str(tmp_path / "data" / "raw.h5")
+    if spelling == "relative_parts":
+        other = str(tmp_path / "data" / ".." / "data" / "raw.h5")
+    elif sys.platform != "win32":
+        pytest.skip("Windows only")
+    elif spelling == "separators":
+        other = filename.replace("\\", "/")
+    else:
+        other = filename.upper()
+    assert _same_file(filename, other)

ewoksdata-2.3.0rc5/src/ewoksdata/tests/unit/test_nfs.py

@@ -0,0 +1,39 @@
+import os
+import sys
+
+import pytest
+
+from ...data.nfs import nfs_cache_refresh
+
+
+def test_nfs_cache_refresh(tmp_path):
+    filename = tmp_path / "subdir" / "file.txt"
+    filename.parent.mkdir()
+    filename.write_text("content")
+
+    nfs_cache_refresh(
+        filename,
+        str(filename),
+        filename.parent,
+        tmp_path / "missing" / "file.txt",
+        tmp_path / "subdir" / "missing.txt",
+    )
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32" or os.geteuid() == 0,
+    reason="permissions are not enforced",
+)
+def test_nfs_cache_refresh_no_permission(tmp_path):
+    filename = tmp_path / "file.txt"
+    filename.write_text("content")
+    dirname = tmp_path / "subdir"
+    dirname.mkdir()
+
+    filename.chmod(0)
+    dirname.chmod(0)
+    try:
+        nfs_cache_refresh(filename, dirname, dirname / "file.txt")
+    finally:
+        dirname.chmod(0o755)
+        filename.chmod(0o644)

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata/tests/unit/test_overwrite_hdf5.py

@@ -35,6 +35,7 @@ def test_ensure_items_do_not_exist_some_top_level(tmp_path):
         f["3.1/soft"] = h5py.SoftLink("/2.1/data")
         f["3.1/external"] = h5py.ExternalLink("other.h5", "/data")
     os.chmod(filename, 0o644)
+    mode_before = stat.S_IMODE(os.stat(filename).st_mode)
     size_before = os.path.getsize(filename)
 
     ensure_items_do_not_exist(f"{filename}::/1.1", delete_existing=True)
@@ -47,7 +48,7 @@ def test_ensure_items_do_not_exist_some_top_level(tmp_path):
         assert f.get("3.1/soft", getlink=True).path == "/2.1/data"
         assert f.get("3.1/external", getlink=True).filename == "other.h5"
     assert os.path.getsize(filename) < size_before / 10
-    assert stat.S_IMODE(os.stat(filename).st_mode) == 0o644
+    assert stat.S_IMODE(os.stat(filename).st_mode) == mode_before
     assert os.listdir(tmp_path) == ["test.h5"]
 
 

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5/src/ewoksdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ewoksdata
-Version: 2.3.0rc4
+Version: 2.3.0rc5
 Summary: Ewoks tasks for data access
 Author-email: ESRF <dau-pydev@esrf.fr>
 License: # MIT License
@@ -49,7 +49,9 @@ Provides-Extra: online
 Requires-Dist: blissdata[lima2,tango]; extra == "online"
 Provides-Extra: test
 Requires-Dist: ewoksdata[online]; extra == "test"
-Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest>=7; python_full_version != "3.10.0" and extra == "test"
+Requires-Dist: pytest<9.2,>=7; python_full_version == "3.10.0" and extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ewoksdata[test]; extra == "dev"
 Requires-Dist: ruff; extra == "dev"

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/ewoksdata/data/__init__.py
 src/ewoksdata/data/bliss.py
 src/ewoksdata/data/contextiterator.py
 src/ewoksdata/data/nexus.py
+src/ewoksdata/data/nfs.py
 src/ewoksdata/data/url.py
 src/ewoksdata/data/utils.py
 src/ewoksdata/data/blissdata/__init__.py
@@ -32,7 +33,9 @@ src/ewoksdata/data/hdf5/dataset_writer/_sequential_stack.py
 src/ewoksdata/tests/__init__.py
 src/ewoksdata/tests/integration/__init__.py
 src/ewoksdata/tests/integration/conftest.py
-src/ewoksdata/tests/integration/test_blissdata.py
+src/ewoksdata/tests/integration/test_iter_memory.py
+src/ewoksdata/tests/integration/test_iter_memory_live.py
+src/ewoksdata/tests/integration/test_last_lima_image.py
 src/ewoksdata/tests/unit/__init__.py
 src/ewoksdata/tests/unit/conftest.py
 src/ewoksdata/tests/unit/test_contextiterator.py
@@ -42,6 +45,7 @@ src/ewoksdata/tests/unit/test_data_nexus.py
 src/ewoksdata/tests/unit/test_dataset_writer.py
 src/ewoksdata/tests/unit/test_find_lima_scans.py
 src/ewoksdata/tests/unit/test_mirror_hdf5.py
+src/ewoksdata/tests/unit/test_nfs.py
 src/ewoksdata/tests/unit/test_overwrite_hdf5.py
 src/ewoksdata/tests/unit/data/__init__.py
 src/ewoksdata/tests/unit/data/bliss_scans.py

{ewoksdata-2.3.0rc4 → ewoksdata-2.3.0rc5}/src/ewoksdata.egg-info/requires.txt

@@ -26,4 +26,10 @@ blissdata[lima2,tango]
 
 [test]
 ewoksdata[online]
+pytest-timeout
+
+[test:python_full_version != "3.10.0"]
 pytest>=7
+
+[test:python_full_version == "3.10.0"]
+pytest<9.2,>=7