ewoksdata 2.1.0__py3-none-any.whl

ewoksdata/tests/test_contextiterator.py

@@ -0,0 +1,61 @@
+from ..data import contextiterator
+
+
+def test_context_iterator():
+
+    exited = False
+
+    @contextiterator.contextiterator
+    def iterator():
+        nonlocal exited
+        exited = False
+        try:
+            yield from [1, 2, 3]
+        finally:
+            exited = True
+
+    # Use like a normal iterator
+    it = iterator()
+    assert next(it) == 1
+    assert not exited
+
+    # Use like a context iterator
+    with iterator() as it:
+        assert next(it) == 1
+        assert not exited
+    assert exited
+
+
+def test_context_generator():
+
+    @contextiterator.contextiterator
+    def generator():
+        nonlocal exited
+        exited = False
+        try:
+            while True:
+                x = yield
+                yield x * 2
+        finally:
+            exited = True
+
+    # Use like a normal generator
+    exited = False
+    gen = generator()
+    assert next(gen) is None  # run up to first yield
+    assert not exited
+    assert gen.send(10) == 20
+    assert next(gen) is None
+    assert gen.send(15) == 30
+    assert not exited
+
+    # Use like a context iterator
+    exited = False
+    with generator() as gen:
+        assert next(gen) is None
+        assert not exited
+        assert gen.send(10) == 20
+        assert next(gen) is None
+        assert gen.send(15) == 30
+        assert not exited
+    assert exited

ewoksdata/tests/test_data_bliss.py

@@ -0,0 +1,98 @@
+import h5py
+import numpy
+import pytest
+from fabio.edfimage import edfimage
+
+from ..data import bliss
+
+
+def test_get_data_edf(tmpdir):
+    filename = str(tmpdir / "data.edf")
+    img1 = numpy.random.uniform(((10, 12)))
+    edf = edfimage(data=img1)
+    edf.write(filename)
+    img2 = bliss.get_data(filename)
+    numpy.testing.assert_array_equal(img1, img2)
+
+
+def test_get_data_hdf5(tmpdir):
+    filename = str(tmpdir / "data.h5")
+    img1 = numpy.random.uniform(((10, 12)))
+    with h5py.File(filename, "w") as f:
+        f["img"] = img1
+
+    img2 = bliss.get_data(f"{filename}::/img")
+    numpy.testing.assert_array_equal(img1, img2)
+
+    img3 = bliss.get_data(f"{filename}?path=/img")
+    numpy.testing.assert_array_equal(img1, img3)
+
+    filename_non_existing = str(tmpdir / "data_non_existing.h5")
+    with pytest.raises(TimeoutError):
+        _ = bliss.get_data(f"{filename_non_existing}?path=/img", retry_timeout=0)
+
+    filename_non_existing = str(tmpdir / "data_non_existing.edf")
+    with pytest.raises(TimeoutError):
+        _ = bliss.get_data(filename_non_existing, retry_timeout=0)
+
+
+@pytest.mark.parametrize("lima_names", [(), ("p3",), ("p3", "p4")])
+@pytest.mark.parametrize("counter_names", [(), ("diode1",), ("diode1", "diode2")])
+def test_iter_bliss_data(lima_names, counter_names, bliss_scan):
+    nexpected = len(lima_names) + len(counter_names)
+    index = None
+    filename, npoints, scan_nb = bliss_scan
+    with bliss.iter_bliss_data(
+        filename, scan_nb, lima_names=lima_names, counter_names=counter_names
+    ) as bliss_data_iterator:
+        for index, data in bliss_data_iterator:
+            assert len(data) == nexpected
+            if "diode1" in counter_names:
+                assert data["diode1"] == index
+            if "diode2" in counter_names:
+                assert data["diode2"] == index
+            if "p3" in lima_names:
+                assert (data["p3"] == index).all()
+            if "p4" in lima_names:
+                assert (data["p4"] == index).all()
+
+    if nexpected:
+        assert index == npoints - 1
+    else:
+        assert index is None
+
+
+@pytest.mark.parametrize(
+    "lima_names,counter_names",
+    [
+        ([""], []),
+        ([" "], []),
+        ([], [""]),
+        ([], [" "]),
+    ],
+)
+def test_iter_bliss_data_invalid_names(bliss_scan, lima_names, counter_names):
+    filename, _, scan_nb = bliss_scan
+    with bliss.iter_bliss_data(
+        filename, scan_nb, lima_names=lima_names, counter_names=counter_names
+    ) as bliss_data_iterator:
+        with pytest.raises(ValueError) as exc_info:
+            next(bliss_data_iterator)
+    assert "Invalid LIMA name" in str(exc_info.value) or "Invalid Counter name" in str(
+        exc_info.value
+    )
+
+
+def test_closure_of_iter_bliss_data(bliss_scan):
+    filename, npoints, scan_nb = bliss_scan
+
+    # This opens filename with `locking=False`
+    with bliss.iter_bliss_data(
+        filename, scan_nb, counter_names=[], lima_names=("p3",)
+    ) as lima_iterator:
+        for i in range(npoints):
+            next(lima_iterator)
+
+    # Make sure that the file is closed and can be reopened with a different locking flag
+    with h5py.File(filename, "r", locking=True):
+        pass

ewoksdata/tests/test_data_hdf5.py

@@ -0,0 +1,14 @@
+from ..data import hdf5
+
+
+def test_bliss_data(bliss_scan):
+    filename, nb_points, scan_nb = bliss_scan
+    with hdf5.h5context(filename) as f:
+        values = f[f"/{scan_nb}.1/measurement/diode1"][()]
+        assert values.tolist() == list(range(nb_points))
+        values = f[f"/{scan_nb}.1/measurement/diode2"][()]
+        assert values.tolist() == list(range(nb_points))
+        values = f[f"/{scan_nb}.1/measurement/p3"][:, 0, 0]
+        assert values.tolist() == list(range(nb_points))
+        values = f[f"/{scan_nb}.1/measurement/p3"][:, -1, -1]
+        assert values.tolist() == list(range(nb_points))

ewoksdata/tests/test_data_nexus.py

@@ -0,0 +1,80 @@
+import time
+
+import pytest
+from silx.io import h5py_utils
+from silx.io.url import DataUrl
+
+from ..data import nexus
+from ..data import url
+
+
+def test_create_nexus_group(tmp_path):
+    with nexus.create_nexus_group(str(tmp_path / "file.h5")) as (
+        h5item,
+        already_existed,
+    ):
+        assert not already_existed
+        assert h5item.name == "/results"
+    with nexus.create_nexus_group(str(tmp_path / "file.h5")) as (
+        h5item,
+        already_existed,
+    ):
+        assert already_existed
+        assert h5item.name == "/results"
+
+    with nexus.create_nexus_group(
+        str(tmp_path / "file.h5::/c"), default_levels=("a", "b")
+    ) as (h5item, already_existed):
+        assert not already_existed
+        assert h5item.name == "/c/b"
+    with nexus.create_nexus_group(
+        str(tmp_path / "file.h5::/c"), default_levels=("a", "b")
+    ) as (h5item, already_existed):
+        assert already_existed
+        assert h5item.name == "/c/b"
+    with nexus.create_nexus_group(str(tmp_path / "file.h5::/c/b")) as (
+        h5item,
+        already_existed,
+    ):
+        assert already_existed
+        assert h5item.name == "/c/b"
+
+
+@pytest.mark.parametrize("as_string", [True, False])
+@pytest.mark.parametrize("data_path", ["", "::/1.1/measurement/integrated"])
+def test_create_url(tmp_path, data_path, as_string):
+    tmp_url = DataUrl(f"{tmp_path / 'file.h5'}{data_path}")
+
+    if data_path:
+        expected_url = url.as_dataurl(tmp_url.path())
+    else:
+        expected_url = url.as_dataurl(f"{tmp_url.path()}::/results")
+
+    if as_string:
+        input_url = tmp_url.path()
+    else:
+        input_url = tmp_url
+
+    created_url = nexus.create_url(input_url)
+    assert created_url == expected_url
+
+    with h5py_utils.open_item(
+        created_url.file_path(), created_url.data_path(), mode="a"
+    ) as item:
+        # Add unique id to identify the item
+        item_id = f"CREATED AT {time.time()}"
+        item.attrs["id"] = item_id
+
+    created_url = nexus.create_url(input_url, overwrite=False)
+    with h5py_utils.open_item(
+        created_url.file_path(), created_url.data_path()
+    ) as new_item:
+        # It is the same item
+        assert new_item.attrs["id"] == item_id
+
+    created_url = nexus.create_url(input_url, overwrite=True)
+    with h5py_utils.open_item(
+        created_url.file_path(), created_url.data_path()
+    ) as new_item:
+        # It is a different item
+        assert "id" not in new_item.attrs

ewoksdata/tests/test_dataset_writer.py

@@ -0,0 +1,275 @@
+import itertools
+import multiprocessing
+import time
+
+import h5py
+import numpy
+import pytest
+from silx.io import h5py_utils
+
+from ..data.hdf5 import dataset_writer
+
+
+@pytest.mark.parametrize("npoints", (1, 3, 1000))
+@pytest.mark.parametrize("flush_period", (None, 0.1))
+@pytest.mark.parametrize("known_npoints", (True, False))
+def test_dataset_writer(tmp_path, npoints, flush_period, known_npoints):
+    expected = list()
+    filename = str(tmp_path / "test.h5")
+    if flush_period is None:
+        sleep_time = None
+    else:
+        sleep_time = flush_period + 0.1
+    isleep = npoints // 3
+
+    kwargs = {"flush_period": flush_period}
+    if known_npoints:
+        kwargs["npoints"] = npoints
+
+    with h5py.File(filename, mode="w") as f:
+        with dataset_writer.DatasetWriter(f, "data", **kwargs) as writer:
+            for ipoint in range(npoints):
+                data = numpy.random.random((10, 20))
+                writer.add_point(data)
+                expected.append(data)
+                if sleep_time and ipoint == isleep:
+                    time.sleep(sleep_time)
+
+    with h5py.File(filename, mode="r") as f:
+        data = f["data"][()]
+    numpy.testing.assert_allclose(data, expected)
+
+
+@pytest.mark.parametrize("nstack", (1, 4))
+@pytest.mark.parametrize("npoints", (1, 3, 1000))
+@pytest.mark.parametrize("flush_period", (None, 0.1))
+@pytest.mark.parametrize("known_npoints", (True, False))
+@pytest.mark.parametrize("known_nstack", (True, False))
+@pytest.mark.parametrize("append_stacks_in_parallel", (True, False))
+def test_stack_dataset_writer(
+    tmp_path,
+    nstack,
+    npoints,
+    flush_period,
+    known_npoints,
+    known_nstack,
+    append_stacks_in_parallel,
+):
+    expected = [list() for _ in range(nstack)]
+    filename = str(tmp_path / "test.h5")
+    if flush_period is None:
+        sleep_time = None
+    else:
+        sleep_time = flush_period + 0.1
+    isleep = (nstack * npoints) // 3
+
+    kwargs = {"flush_period": flush_period}
+    if known_npoints:
+        kwargs["npoints"] = npoints
+    if known_nstack:
+        kwargs["nstack"] = nstack
+
+    if append_stacks_in_parallel:
+        itpoints = itertools.product(range(npoints), range(nstack))
+    else:
+        itpoints = itertools.product(range(nstack), range(npoints))
+
+    with h5py.File(filename, mode="w") as f:
+        with dataset_writer.StackDatasetWriter(f, "data", **kwargs) as writer:
+            for tpl in itpoints:
+                if append_stacks_in_parallel:
+                    ipoint, istack = tpl
+                else:
+                    istack, ipoint = tpl
+                data = numpy.random.random((10, 20))
+                writer.add_point(data, istack)
+                expected[istack].append(data)
+                if sleep_time and (ipoint * nstack + istack) == isleep:
+                    time.sleep(sleep_time)
+
+    with h5py.File(filename, mode="r") as f:
+        data = f["data"][()]
+    numpy.testing.assert_allclose(data, expected)
+
+
+@pytest.mark.parametrize("npoints", (1, 3, 1000))
+@pytest.mark.parametrize("flush_period", (None, 0.1))
+@pytest.mark.parametrize("known_npoints", (True, False))
+def test_indexed_dataset_writer(tmp_path, npoints, flush_period, known_npoints):
+    filename = str(tmp_path / "test.h5")
+
+    if flush_period is None:
+        sleep_time = None
+    else:
+        sleep_time = flush_period + 0.1
+
+    isleep = npoints // 3
+
+    kwargs = {"flush_period": flush_period}
+    if known_npoints:
+        kwargs["npoints"] = npoints
+
+    # Generate data and shuffled indices
+    indices = numpy.arange(npoints)
+    numpy.random.shuffle(indices)
+
+    expected = [None] * npoints
+    data_points = [numpy.random.random((10, 20)) for _ in range(npoints)]
+    for idx, data in zip(indices, data_points):
+        expected[idx] = data
+
+    with h5py.File(filename, mode="w") as f:
+        with dataset_writer.IndexedDatasetWriter(f, "data", **kwargs) as writer:
+            for i, (idx, data) in enumerate(zip(indices, data_points)):
+                writer.add_point(data, idx)
+                if sleep_time and i == isleep:
+                    time.sleep(sleep_time)
+
+    with h5py.File(filename, mode="r") as f:
+        data = f["data"][()]
+
+    numpy.testing.assert_allclose(data, expected)
+
+
+@pytest.mark.parametrize("nstack", (1, 4))
+@pytest.mark.parametrize("npoints", (1, 3, 100))
+@pytest.mark.parametrize("flush_period", (None, 0.1))
+@pytest.mark.parametrize("known_npoints", (True, False))
+@pytest.mark.parametrize("known_nstack", (True, False))
+def test_indexed_stack_dataset_writer(
+    tmp_path,
+    nstack,
+    npoints,
+    flush_period,
+    known_npoints,
+    known_nstack,
+):
+    filename = str(tmp_path / "test.h5")
+
+    if flush_period is None:
+        sleep_time = None
+    else:
+        sleep_time = flush_period + 0.1
+
+    isleep = (nstack * npoints) // 3
+
+    kwargs = {"flush_period": flush_period}
+    if known_npoints:
+        kwargs["npoints"] = npoints
+    if known_nstack:
+        kwargs["nstack"] = nstack
+
+    # Generate data and shuffled indices
+    indices = list(itertools.product(range(nstack), range(npoints)))
+    numpy.random.shuffle(indices)
+
+    expected = [[None for _ in range(npoints)] for _ in range(nstack)]
+    values = [numpy.random.random((10, 20)) for _ in indices]
+
+    for (istack, ipoint), value in zip(indices, values):
+        expected[istack][ipoint] = value
+
+    with h5py.File(filename, mode="w") as f:
+        with dataset_writer.IndexedStackDatasetWriter(f, "data", **kwargs) as writer:
+            for i, ((istack, ipoint), value) in enumerate(zip(indices, values)):
+                writer.add_point(value, istack, ipoint)
+                if sleep_time and i == isleep:
+                    time.sleep(sleep_time)
+
+    with h5py.File(filename, mode="r") as f:
+        data = f["data"][()]
+
+    numpy.testing.assert_allclose(data, expected)
+
+
+def test_concurrent_reader(tmp_path):
+    npoints = 50
+    hdf5_filename = str(tmp_path / "test.h5")
+    read_timestamps = str(tmp_path / "read_timestamps.log")
+    write_timestamps = str(tmp_path / "write_timestamps.log")
+    dataset_name = "data"
+
+    # Run read loop in a sub-process
+    start_event = multiprocessing.Event()
+    reader_process = multiprocessing.Process(
+        target=_read_hdf5_file,
+        args=(hdf5_filename, dataset_name, npoints, read_timestamps, start_event),
+    )
+    reader_process.start()
+
+    assert start_event.wait(timeout=10)
+
+    # Run write loop
+    try:
+        _write_hdf5_file(hdf5_filename, dataset_name, npoints, write_timestamps)
+    except Exception:
+        reader_process.terminate()
+        raise
+
+    # Wait for read loop to finish
+    try:
+        reader_process.join(timeout=10)
+        if reader_process.exitcode is None:
+            raise TimeoutError("Reader process did not terminate within the timeout.")
+        elif reader_process.exitcode != 0:
+            raise RuntimeError(
+                f"Reader process terminated with exit code {reader_process.exitcode}."
+            )
+    except Exception:
+        reader_process.terminate()
+        raise
+
+    # Check that reading and writing happened concurrently
+    with open(read_timestamps, "r") as eventfile:
+        read_events = [int(line.strip()) for line in eventfile.readlines()]
+    with open(write_timestamps, "r") as eventfile:
+        write_events = [int(line.strip()) for line in eventfile.readlines()]
+
+    assert len(read_events) == npoints
+    assert len(write_events) == npoints
+
+    all_events = sorted(read_events + write_events)
+    assert (
+        read_events != all_events[: len(read_events)]
+    ), "reads and writes are not interleaved"
+
+
+class _DatasetWriter(dataset_writer.DatasetWriter):
+    """Testing concurrent reading and writing always ends up
+    being flaky. So we introduce a sleep after flushing
+    to give the reader plenty of time to fetch new data.
+    """
+
+    def _flush_hdf5(self) -> None:
+        print("flush")
+        super()._flush_hdf5()
+        time.sleep(0.2)
+
+
+def _write_hdf5_file(hdf5_filename, dataset_name, npoints, event_filename):
+    data = numpy.zeros((500, 500), dtype=numpy.int64)
+    with open(event_filename, "a") as eventfile:
+        with h5py.File(hdf5_filename, mode="w") as h5file:
+            with _DatasetWriter(h5file, dataset_name) as writer:
+                for i in range(npoints):
+                    writer.add_point(data)
+                    eventfile.write(f"{time.perf_counter_ns()}\n")
+                    print(f"write {i}")
+
+
+def _read_hdf5_file(hdf5_filename, dataset_name, npoints, event_filename, start_event):
+    i = 0
+    with open(event_filename, "a") as eventfile:
+        start_event.set()
+        while i < npoints:
+            for _ in _iter_data(hdf5_filename, dataset_name):
+                eventfile.write(f"{time.perf_counter_ns()}\n")
+                print(f"read {i}")
+                i += 1
+
+
+@h5py_utils.retry()
+def _iter_data(hdf5_filename, dataset_name, start_index=0):
+    with h5py_utils.File(hdf5_filename) as h5file:
+        for _ in h5file[dataset_name][start_index:], start_index:
+            yield None

ewoksdata-2.1.0.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: ewoksdata
+Version: 2.1.0
+Summary: Ewoks tasks for data access
+Author-email: ESRF <dau-pydev@esrf.fr>
+License: # MIT License
+        
+        **Copyright (c) 2021 European Synchrotron Radiation Facility**
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of
+        this software and associated documentation files (the "Software"), to deal in
+        the Software without restriction, including without limitation the rights to
+        use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+        the Software, and to permit persons to whom the Software is furnished to do so,
+        subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+        FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+        COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+        CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksdata/
+Project-URL: Documentation, https://ewoksdata.readthedocs.io
+Project-URL: Repository, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksdata/
+Project-URL: Issues, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksdata/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksdata/-/blob/main/CHANGELOG.md
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: packaging
+Requires-Dist: h5py>=2.8
+Requires-Dist: silx>=1.1.0
+Requires-Dist: hdf5plugin
+Requires-Dist: blissdata>=0.3.4
+Requires-Dist: redis
+Requires-Dist: redis!=5.3.0b1,!=5.3.0b3
+Requires-Dist: redis-om!=1.0.0b0; python_version < "3.9"
+Requires-Dist: redis-om!=1.0.3b0; python_version < "3.9"
+Provides-Extra: online
+Requires-Dist: blissdata[tango]; extra == "online"
+Provides-Extra: test
+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"
+Provides-Extra: doc
+Requires-Dist: ewoksdata[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints>=1.16; extra == "doc"
+Requires-Dist: pydata-sphinx-theme<0.15; extra == "doc"
+Dynamic: license-file
+
+# ewoksdata
+
+Data access utilities for [ewoks](https://ewoks.readthedocs.io/) workflows.
+
+## Documentation
+
+https://ewoksdata.readthedocs.io

ewoksdata-2.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+ewoksdata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ewoksdata/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ewoksdata/data/bliss.py,sha256=yJ2ic00tilevtMpwObconChQoizv47Cr4RlzIP6XwNc,12791
+ewoksdata/data/contextiterator.py,sha256=LSle5CwfHfemfu_7eOY8wHv_kDqARTXaPvkKTJ35xm8,1078
+ewoksdata/data/nexus.py,sha256=V1AC6H-tXwuXoZUl4QQTuoKmEDOIoDJ5T6R5f-1DlZ0,6358
+ewoksdata/data/url.py,sha256=3Fd_8tTXfM2B44EfDKzyo0QL4KSh6QIVfBwj_bPcyPY,762
+ewoksdata/data/utils.py,sha256=zt6Y93xNKqoeWnPPlwg86yGz-s2vEFy1EBkTXrlRHjU,1410
+ewoksdata/data/blissdata/__init__.py,sha256=jbuhm0oFxkf87mlaENmWOlv-ExFuqWSH8IdnYsmc9A8,1162
+ewoksdata/data/blissdata/blissdatav0.py,sha256=v8DPi2bqGtZkT93sLkrxOUyx93dFzT9O3PfMP2MhGRk,4164
+ewoksdata/data/blissdata/blissdatav1.py,sha256=_LfAaLcsbPdOjhE-53kUt7HXdnCf5WRSEBgVc4P388Q,10611
+ewoksdata/data/blissdata/blissdatav2.py,sha256=MBnqao7_auKrYIILB2nvBGaIir843_86vVPoq2N-zD4,12188
+ewoksdata/data/hdf5/__init__.py,sha256=LggGhbjxpR5XF6nDB-eAHPZ-YCWWeuotLEQvTrWEexs,622
+ewoksdata/data/hdf5/config.py,sha256=TwaZXgAoV3vJZTYSr3Oj_AtS3lePUUBj_vdE1FxU81M,6121
+ewoksdata/data/hdf5/types.py,sha256=LKNRsGcBYt6FLRt2oGsUQQsiDaIvZv-X6OSnl0q_BNI,510
+ewoksdata/data/hdf5/dataset_writer/__init__.py,sha256=D-IWijYU3osAPtOvcYmx8VNyHIxMfFHHfEyP3Ps7sFE,252
+ewoksdata/data/hdf5/dataset_writer/_base.py,sha256=DrdC66xK_Px5mT6SRWBbdepwfLSSI4CrugV_-ng48Zw,1470
+ewoksdata/data/hdf5/dataset_writer/_non_sequential.py,sha256=NMzsp7dbeQU6JWEHcelc3Oa5cZgP_qkoqQeYkyNgg34,4188
+ewoksdata/data/hdf5/dataset_writer/_non_sequential_stack.py,sha256=CjhpyDD3jeN5x_oKpR7a7CWTHSPk5Ms6XgEBI1qdMbk,5164
+ewoksdata/data/hdf5/dataset_writer/_sequential.py,sha256=qyzPhG3sGm0rEBrg4jJbm1SOhBeW7hm7kq6oW_vPUcE,4440
+ewoksdata/data/hdf5/dataset_writer/_sequential_stack.py,sha256=ymwU09yNUWQP5YCMuQ8eQPMugPYAUoco2p2W3NuwsiM,7508
+ewoksdata/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ewoksdata/tests/conftest.py,sha256=DNN1bt0VIavqQBfCneKh3WXtK2ytLb5rjjQBVz8XnVQ,666
+ewoksdata/tests/test_contextiterator.py,sha256=a-Elm4SLdvjxaNdTb4WyKCmb33idteQJ6aMbg0X81Cw,1338
+ewoksdata/tests/test_data_bliss.py,sha256=6E3YdjopOF7-Ulns5VzSzlsqiLhqtj8BuwUiXl5AgUw,3202
+ewoksdata/tests/test_data_hdf5.py,sha256=eAvCRvzUWw77q5NGyiDv_rKOEkJXAErDOQtJDlNcPjI,613
+ewoksdata/tests/test_data_nexus.py,sha256=3jON9hBqZ8tJE4jlstmh3ia6GPRMTY3bipM3xnTgrXI,2465
+ewoksdata/tests/test_dataset_writer.py,sha256=YIYDv_84fq7Wc7RBjMrlnHIKiJK_Q1danrh3YTcnpWE,9064
+ewoksdata/tests/data/__init__.py,sha256=Zux5qxSbtT37x4yjtSbU0QZzAKG2t5QPTfAr00R0y-A,40
+ewoksdata/tests/data/bliss_scans.py,sha256=-OcVto9C0cOdHIHQ5YVHBJp7EZG5YC7b12pVzj5cvLQ,4712
+ewoksdata-2.1.0.dist-info/licenses/LICENSE.md,sha256=NJLjvGCcDcGPof6QvVOo_T8F-eu_iF6PBf5m3PlzAbI,1102
+ewoksdata-2.1.0.dist-info/METADATA,sha256=VOrh0mNs0-QEcKMhvmSYAE2fMRz8VqZqBuCnTbsu6dE,3109
+ewoksdata-2.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ewoksdata-2.1.0.dist-info/top_level.txt,sha256=g3W5d3Rdd2kTJ7HJLmXEPJg1OB-Ad7FpNi_rqg_C4J4,10
+ewoksdata-2.1.0.dist-info/RECORD,,

ewoksdata-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ewoksdata-2.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+**Copyright (c) 2021 European Synchrotron Radiation Facility**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ewoksdata-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ewoksdata