blissdata-lima2 2.0__tar.gz → 2.0.2__tar.gz

{blissdata_lima2-2.0 → blissdata_lima2-2.0.2}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: blissdata-lima2
-Version: 2.0
+Version: 2.0.2
 Summary: Lima2 plugin for blissdata
 Maintainer: BCU (ESRF)
 License-Expression: MIT
+Project-URL: Repository, https://gitlab.esrf.fr/bliss/blissdata-lima2
 Keywords: blissdata,lima2
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
@@ -11,11 +12,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: blissdata~=2.3
-Requires-Dist: lima2-client~=4.0
+Requires-Dist: lima2-client~=4.1
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-redis; extra == "dev"
 Dynamic: license-file
 

{blissdata_lima2-2.0 → blissdata_lima2-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "blissdata-lima2"
-version = "2.0"
+version = "2.0.2"
 description = "Lima2 plugin for blissdata"
 readme = "README.md"
 license = "MIT"
@@ -16,10 +16,13 @@ classifiers = [
 ]
 keywords = ["blissdata", "lima2"]
 requires-python = ">=3.10"
-dependencies = ["blissdata~=2.3", "lima2-client~=4.0"]
+dependencies = ["blissdata~=2.3", "lima2-client~=4.1"]
+
+[project.urls]
+Repository = "https://gitlab.esrf.fr/bliss/blissdata-lima2"
 
 [project.optional-dependencies]
-dev = ["black", "flake8", "pytest", "pytest-redis"]
+dev = ["black", "flake8", "mypy", "pytest", "pytest-cov", "pytest-redis"]
 
 [project.entry-points.blissdata]
 lima2 = "blissdata_lima2"

{blissdata_lima2-2.0 → blissdata_lima2-2.0.2}/src/blissdata_lima2/stream.py

@@ -15,17 +15,19 @@ from blissdata.exceptions import (
     EndOfStream,
     IndexNoMoreThereError,
     IndexNotYetThereError,
+    IndexWontBeThereError,
 )
+from blissdata.h5api import dynamic_hdf5
 from blissdata.lima.image_utils import ImageData
 from blissdata.streams import (
     BaseStream,
     BaseView,
     EventRange,
-    EventStream,
     StreamDefinition,
 )
 from blissdata.streams.default import Stream
 from blissdata.streams.encoding.numeric import NumericStreamEncoder
+from blissdata.streams.event_stream import EventStream
 from blissdata.streams.lima.stream import LimaDirectAccess
 from lima2.common.devencoded.sparse_frame import SparseFrame
 from numpy.typing import DTypeLike
@@ -72,24 +74,30 @@ class Lima2View(BaseView):
     def __len__(self) -> int:
         return len(self._idx_range)
 
-    def get_data(
-        self, start: int | None = None, stop: int | None = None
-    ) -> list[ImageData]:
-        try:
-            return [
-                get_frame(
-                    services=self._services,
-                    acq_uuid=self._acq_uuid,
-                    source=self._source,
-                    frame_idx=idx,
+    def get_data(self, start: int | None = None, stop: int | None = None) -> np.ndarray:
+        frames = []
+        for idx in self._idx_range[start:stop]:
+            try:
+                frames.append(
+                    get_frame(
+                        services=self._services,
+                        acq_uuid=self._acq_uuid,
+                        source=self._source,
+                        frame_idx=idx,
+                    ).array
                 )
-                for idx in self._idx_range[start:stop]
-            ]
-        except RuntimeError as e:
-            raise IndexNoMoreThereError(
-                f"Can't fetch {self._source} {self._idx_range[start:stop].start} "
-                f"to {self._idx_range[start:stop].stop}: {e}"
-            ) from e
+            except RuntimeError as e:
+                # Raise if any frame can't be accessed
+                raise IndexNoMoreThereError(
+                    f"Can't fetch {self._source} {self._idx_range[start:stop]}: {e}"
+                ) from e
+            except ValueError as e:
+                # Frame source has no associated memory buffer (raw_frame)
+                raise IndexNoMoreThereError(
+                    f"Can't fetch {self._source}: no associated live data"
+                ) from e
+
+        return np.asarray(frames)
 
 
 class Lima2Stream(BaseStream, LimaDirectAccess):
@@ -120,6 +128,7 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
         self._shape = tuple(event_stream.info["shape"])
         self._acq_uuid = str(event_stream.info["acq_uuid"])
         self._source = str(event_stream.info["source_name"])
+        self._master_file: tuple[str, str] | None = event_stream.info["master_file"]
 
         self._services = l2s.init(
             hostname=str(event_stream.info["conductor_hostname"]),
@@ -132,8 +141,14 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
 
         self._cursor = Stream(event_stream).cursor()
 
+        self._services.handshake()
+
+    ####################################################################################
+    # BaseStream
+    ####################################################################################
+
     @property
-    def kind(self):
+    def kind(self) -> str:
         return "array"
 
     @staticmethod
@@ -145,7 +160,7 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
         acq_uuid: str,
         master_file: tuple[str, str] | None,
         dtype: DTypeLike,
-        shape: Sequence,
+        shape: Sequence[int],
     ) -> StreamDefinition:
         info = {
             "plugin": "lima2",
@@ -184,34 +199,43 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
             self._length = int(last_status)
         return self._length
 
-    def __getitem__(self, key: int | slice) -> ImageData | list[ImageData]:
-        idx_range = range(len(self))
-        if type(key) is int:
-            if key < 0 and not self.is_sealed():
-                raise IndexNotYetThereError(
-                    "Can't index from end of stream until it is sealed"
-                )
-            return get_frame(
-                services=self._services,
-                acq_uuid=self._acq_uuid,
-                source=self._source,
-                frame_idx=idx_range[key],
-            )
-        elif type(key) is slice:
-            if not self.is_sealed() and ((key.start or 0) < 0 or (key.stop or 0) < 0):
-                raise IndexNotYetThereError(
-                    "Can't slice from end of stream until it is sealed"
-                )
+    def __getitem__(self, key: int | slice) -> np.ndarray:
+        sealed = self.is_sealed()
+        if isinstance(key, int):
+            size = len(self)
+            if key < 0:
+                if not sealed:
+                    raise IndexNotYetThereError(
+                        "Can't index from end of stream until it is sealed"
+                    )
+                else:
+                    key += size
+
+            if not 0 <= key < size:
+                # Fail early if we're out of bounds
+                if sealed:
+                    raise IndexWontBeThereError(
+                        f"Frame {key} is out of range (0..{size-1})"
+                    )
+                else:
+                    raise IndexNotYetThereError(
+                        f"Frame {key} is out of range (0..{size-1})"
+                    )
+
+            return self._fetch_frames(start=key, stop=key + 1, step=1)[0]
+
+        elif isinstance(key, slice):
+            if (key.start or 0) < 0 or (key.stop or 0) < 0:
+                if not sealed:
+                    raise IndexNotYetThereError(
+                        "Can't slice from end of stream until it is sealed"
+                    )
+
+            # Resolve the slice in the standard way
+            start, stop, step = key.indices(len(self))
+
+            return self._fetch_frames(start=start, stop=stop, step=step)
 
-            return [
-                get_frame(
-                    services=self._services,
-                    acq_uuid=self._acq_uuid,
-                    source=self._source,
-                    frame_idx=idx,
-                )
-                for idx in idx_range[key]
-            ]
         else:
             raise TypeError(f"{type(key)}")
 
@@ -245,6 +269,10 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
             stop=stop_idx,
         )
 
+    ####################################################################################
+    # LimaDirectAccess
+    ####################################################################################
+
     def get_last_live_image(self) -> ImageData:
         return get_frame(
             services=self._services,
@@ -252,3 +280,72 @@ class Lima2Stream(BaseStream, LimaDirectAccess):
             source=self._source,
             frame_idx=-1,
         )
+
+    ####################################################################################
+    # Private API
+    ####################################################################################
+
+    def _fetch_frames(self, start: int, stop: int, step: int) -> np.ndarray:
+        """Get frame data online or offline, depending on the current state."""
+        if self.is_sealed():
+            if self._master_file is not None:
+                # Default to an offline lookup
+                filepath, datapath = self._master_file
+                return self._fetch_from_disk(
+                    filepath=filepath,
+                    datapath=datapath,
+                    start=start,
+                    stop=stop,
+                    step=step,
+                )
+            else:
+                # Try online, in case backends still have the frames we want
+                _logger.warning(
+                    f"Requesting frames {start}:{stop}:{step} after stream is sealed, "
+                    f"but this frame source ({self._source}) isn't persistent."
+                )
+                return self._fetch_online(start=start, stop=stop, step=step)
+
+        else:
+            return self._fetch_online(start=start, stop=stop, step=step)
+
+    def _fetch_online(self, start: int, stop: int, step: int) -> np.ndarray:
+        """Get frame data directly from the Lima2 devices."""
+        _logger.info(
+            f"Fetching {self._source} {start}:{stop}:{step} from lima2 backend"
+        )
+
+        frames = []
+        for idx in range(start, stop, step):
+            try:
+                frames.append(
+                    get_frame(
+                        services=self._services,
+                        acq_uuid=self._acq_uuid,
+                        source=self._source,
+                        frame_idx=idx,
+                    ).array
+                )
+            except RuntimeError as e:
+                # Raise if any frame can't be accessed
+                raise IndexNoMoreThereError(
+                    f"Can't fetch {self._source} {range(start, stop, step)}: {e}"
+                ) from e
+            except ValueError as e:
+                # Frame source has no associated memory buffer (raw_frame)
+                raise IndexNoMoreThereError(
+                    f"Can't fetch {self._source}: no associated live data"
+                ) from e
+
+        return np.asarray(frames)
+
+    def _fetch_from_disk(
+        self, filepath: str, datapath: str, start: int, stop: int, step: int
+    ) -> np.ndarray:
+        """Get frame data from a file (i.e. "offline")."""
+        _logger.info(
+            f"Fetching {self._source} {start}:{stop}:{step} from disk via {filepath}"
+        )
+
+        with dynamic_hdf5.File(filepath, retry_timeout=10, retry_period=1) as file:
+            return file[datapath][start:stop:step]

blissdata_lima2-2.0.2/src/blissdata_lima2/tests/test_lima2_stream.py

@@ -0,0 +1,458 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of the bliss project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+"""Unit test suite for Lima2 stream and view (streams/lima2.py)."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, Mock, call
+from uuid import uuid1
+
+import numpy as np
+import pytest
+from blissdata.exceptions import (
+    EmptyViewException,
+    IndexNoMoreThereError,
+    IndexNotYetThereError,
+    IndexWontBeThereError,
+)
+from blissdata.lima.image_utils import ImageData
+from blissdata.streams import EventRange, EventStream
+from lima2.common.devencoded.sparse_frame import SparseFrame
+
+from blissdata_lima2 import Lima2Stream, Lima2View
+from blissdata_lima2.stream import get_frame
+
+
+@pytest.fixture
+def mock_handshake(monkeypatch):
+    def mock_handshake(self):
+        pass
+
+    monkeypatch.setattr(
+        "lima2.client.services.ConductorServices.handshake", mock_handshake
+    )
+
+
+def test_lima2_get_frame():
+    services = Mock()
+    uuid = str(uuid1())
+    frm = get_frame(services=services, acq_uuid=uuid, source="cafe", frame_idx=123)
+    services.pipeline.get_frame.assert_called_with(
+        frame_idx=123, source="cafe", uuid=uuid
+    )
+    assert type(frm) is ImageData
+
+
+def test_lima2_get_sparse_frame():
+    mock_frame = Mock(spec=SparseFrame)
+
+    def mock_pipeline_get_frame(frame_idx, source, uuid):
+        return mock_frame
+
+    mock_services = SimpleNamespace(
+        pipeline=SimpleNamespace(get_frame=mock_pipeline_get_frame)
+    )
+
+    uuid = str(uuid1())
+    img_data = get_frame(
+        services=mock_services, acq_uuid=uuid, source="cafe", frame_idx=123
+    )
+    mock_frame.densify.assert_called_once()
+    assert type(img_data) is ImageData
+
+
+def test_lima2_view(monkeypatch):
+    services = Mock()
+    uuid = str(uuid1())
+    view = Lima2View(
+        services=services,
+        acq_uuid=uuid,
+        source="cafe",
+        start=0,
+        stop=42,
+    )
+    assert len(view) == 42
+    assert view.index == 0
+
+    frames = view.get_data()
+    assert len(frames) == len(view)
+
+    services.pipeline.get_frame.assert_has_calls(
+        [call(uuid=uuid, source="cafe", frame_idx=i) for i in range(42)]
+    )
+
+    # RuntimeError
+    def mock_get_frame_runtime_error(services, acq_uuid, source, frame_idx):
+        raise RuntimeError("frame has left the buffer")
+
+    monkeypatch.setattr(
+        "blissdata_lima2.stream.get_frame", mock_get_frame_runtime_error
+    )
+
+    with pytest.raises(IndexNoMoreThereError):
+        frames = view.get_data()
+
+    # ValueError
+    def mock_get_frame_value_error(services, acq_uuid, source, frame_idx):
+        raise ValueError("no such frame buffer")
+
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame_value_error)
+
+    with pytest.raises(IndexNoMoreThereError):
+        frames = view.get_data()
+
+
+def test_lima2_protocol(data_store):
+    uuid = str(uuid1())
+
+    stream_def = Lima2Stream.make_definition(
+        name="device:cafe",
+        source_name="cafe",
+        conductor_hostname="www.lima2.org",
+        conductor_port=12345,
+        acq_uuid=uuid,
+        master_file=None,
+        dtype=np.float128,  # fat pixels >:)
+        shape=(4, 1024, 512),
+    )
+    model = data_store._stream_model(
+        encoding=stream_def.encoder.info(), info=stream_def.info
+    )
+    model.info["protocol_version"] = 1  # hack the protocol number
+    event_stream = EventStream.create(data_store, stream_def.name, model)
+
+    with pytest.raises(RuntimeError):
+        _ = Lima2Stream(event_stream=event_stream)
+
+
+@pytest.fixture
+def lima2_stream(data_store, mock_handshake):
+    uuid = str(uuid1())
+
+    stream_def = Lima2Stream.make_definition(
+        name="device:cafe",
+        source_name="cafe",
+        conductor_hostname="www.lima2.org",
+        conductor_port=12345,
+        acq_uuid=uuid,
+        master_file=None,
+        dtype=np.float128,  # fat pixels >:)
+        shape=(4, 1024, 512),
+    )
+    model = data_store._stream_model(
+        encoding=stream_def.encoder.info(), info=stream_def.info
+    )
+
+    event_stream = EventStream.create(data_store, stream_def.name, model)
+    stream = Lima2Stream(event_stream=event_stream)
+
+    return (stream_def, event_stream, stream)
+
+
+def test_lima2_stream_attributes(lima2_stream):
+    stream_def, event_stream, stream = lima2_stream
+
+    assert stream.plugin == "lima2"
+    assert stream.shape == stream_def.info["shape"]
+    assert stream.kind == "array"
+    assert stream.dtype == stream._dtype
+    assert stream._need_last_only(last_only=True)
+    assert stream._need_last_only(last_only=False)
+
+
+def test_lima2_stream_indexing(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    # Feed the event stream
+    event_stream.send(np.uint32(42))
+    event_stream.join()
+    assert len(stream) == 42
+
+    event_stream.send(np.uint32(123))
+    event_stream.join()
+    assert len(stream) == 123
+
+    mock_get_frame = Mock()
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
+
+    # Indexing
+    _ = stream[0]
+    mock_get_frame.assert_called_with(
+        services=stream._services,
+        acq_uuid=stream._acq_uuid,
+        source="cafe",
+        frame_idx=0,
+    )
+
+    with pytest.raises(IndexNotYetThereError):
+        _ = stream[-1]
+
+    with pytest.raises(IndexNotYetThereError):
+        _ = stream[123123]  # wayyy out of bounds, but we're not sealed yet
+
+    with monkeypatch.context() as mpc:
+        mpc.setattr(stream, "is_sealed", lambda: True)
+
+        with pytest.raises(IndexWontBeThereError):
+            _ = stream[123123]  # wayyy out of bounds and we're sealed
+
+    event_stream.seal()
+    event_stream.join()
+
+    _ = stream[-3]
+    assert mock_get_frame.mock_calls[-1] == call(
+        services=stream._services,
+        acq_uuid=stream._acq_uuid,
+        source="cafe",
+        frame_idx=123 - 3,
+    )
+
+
+def test_lima2_stream_slicing(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    # Feed the event stream
+    event_stream.send(np.uint32(42))
+    event_stream.join()
+    assert len(stream) == 42
+
+    event_stream.send(np.uint32(123))
+    event_stream.join()
+    assert len(stream) == 123
+
+    mock_get_frame = Mock()
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
+
+    # Slicing
+    _ = stream[:3]
+    assert mock_get_frame.mock_calls[-3:] == [
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=0,
+        ),
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=1,
+        ),
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=2,
+        ),
+    ]
+
+    with pytest.raises(IndexNotYetThereError):
+        _ = stream[-2:]
+
+    with pytest.raises(IndexNotYetThereError):
+        _ = stream[:-2]
+
+    with pytest.raises(TypeError):
+        _ = stream["hi :)"]
+
+    event_stream.seal()
+    event_stream.join()
+
+    # Now slicing/indexing from end is ok
+    _ = stream[-2:]
+    assert mock_get_frame.mock_calls[-2:] == [
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=123 - 2,
+        ),
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=123 - 1,
+        ),
+    ]
+
+    _ = stream[:]
+    assert mock_get_frame.mock_calls[-123:] == [
+        call(
+            services=stream._services,
+            acq_uuid=stream._acq_uuid,
+            source="cafe",
+            frame_idx=i,
+        )
+        for i in range(123)
+    ]
+
+    _ = stream.get_last_live_image()
+    mock_get_frame.assert_called_with(
+        services=stream._services,
+        acq_uuid=stream._acq_uuid,
+        source="cafe",
+        frame_idx=-1,
+    )
+
+
+def test_lima2_stream_build_view(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    mock_get_frame = Mock()
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
+
+    view = stream._build_view_from_events(
+        index=0,
+        events=EventRange(
+            index=0,
+            nb_expired=0,
+            data=[np.uint32(5), np.uint32(24), np.uint32(42)],
+            end_of_stream=False,
+        ),
+        last_only=False,
+    )
+    assert view._idx_range == range(0, 42)
+
+    view = stream._build_view_from_events(
+        index=0,
+        events=EventRange(
+            index=0,
+            nb_expired=0,
+            data=[np.uint32(5), np.uint32(24), np.uint32(42)],
+            end_of_stream=False,
+        ),
+        last_only=True,
+    )
+    assert view._idx_range == range(41, 42)
+
+    with pytest.raises(EmptyViewException):
+        # index >= data[-1]
+        view = stream._build_view_from_events(
+            index=42,
+            events=EventRange(
+                index=0,
+                nb_expired=0,
+                data=[np.uint32(5), np.uint32(24), np.uint32(42)],
+                end_of_stream=False,
+            ),
+            last_only=False,
+        )
+
+
+def test_lima2_stream_fetch_frames(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    mock_get_frame = Mock()
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
+
+    with monkeypatch.context() as mpc:
+        # Stream sealed, has master file
+        mock_fetch = Mock()
+        mpc.setattr(stream, "_fetch_from_disk", mock_fetch)
+        mpc.setattr(stream, "is_sealed", lambda: True)
+        mpc.setattr(
+            stream,
+            "_master_file",
+            ("/path/to/master.h5", "entry/instrument/detector/dataset"),
+        )
+
+        stream._fetch_frames(start=0, stop=42, step=3)
+
+        mock_fetch.assert_called_once_with(
+            filepath="/path/to/master.h5",
+            datapath="entry/instrument/detector/dataset",
+            start=0,
+            stop=42,
+            step=3,
+        )
+
+    with monkeypatch.context() as mpc:
+        # Stream sealed, no master file
+        mock_fetch = Mock()
+        mpc.setattr(stream, "_fetch_online", mock_fetch)
+        mpc.setattr(stream, "is_sealed", lambda: True)
+        mpc.setattr(stream, "_master_file", None)
+
+        stream._fetch_frames(start=0, stop=42, step=3)
+
+        mock_fetch.assert_called_once_with(
+            start=0,
+            stop=42,
+            step=3,
+        )
+
+    with monkeypatch.context() as mpc:
+        # Stream not sealed
+        mock_fetch = Mock()
+        mpc.setattr(stream, "_fetch_online", mock_fetch)
+        mpc.setattr(stream, "is_sealed", lambda: False)
+
+        stream._fetch_frames(start=0, stop=42, step=3)
+
+        mock_fetch.assert_called_once_with(
+            start=0,
+            stop=42,
+            step=3,
+        )
+
+
+def test_lima2_stream_fetch_online(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    mock_get_frame = Mock()
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
+
+    stream._fetch_online(start=0, stop=42, step=3)
+
+    mock_get_frame.assert_has_calls(
+        [
+            call(
+                services=stream._services,
+                acq_uuid=stream._acq_uuid,
+                source=stream._source,
+                frame_idx=idx,
+            )
+            for idx in range(0, 42, 3)
+        ]
+    )
+
+    # RuntimeError
+    def mock_get_frame_runtime_error(services, acq_uuid, source, frame_idx):
+        raise RuntimeError("oh no :(")
+
+    monkeypatch.setattr(
+        "blissdata_lima2.stream.get_frame", mock_get_frame_runtime_error
+    )
+
+    with pytest.raises(IndexNoMoreThereError):
+        _ = stream._fetch_online(start=0, stop=1, step=1)
+
+    # ValueError
+    def mock_get_frame_value_error(services, acq_uuid, source, frame_idx):
+        raise ValueError("oh no :(")
+
+    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame_value_error)
+
+    with pytest.raises(IndexNoMoreThereError):
+        _ = stream._fetch_online(start=0, stop=1, step=1)
+
+
+def test_lima2_stream_fetch_offline(lima2_stream, monkeypatch):
+    stream_def, event_stream, stream = lima2_stream
+
+    mock_dynamic_hdf5 = MagicMock()
+    monkeypatch.setattr("blissdata_lima2.stream.dynamic_hdf5", mock_dynamic_hdf5)
+
+    stream._fetch_from_disk(
+        filepath="/path/to/master.h5",
+        datapath="entry/instrument/detector/dataset",
+        start=0,
+        stop=42,
+        step=3,
+    )
+
+    mock_dynamic_hdf5.File.assert_called_once()

{blissdata_lima2-2.0 → blissdata_lima2-2.0.2}/src/blissdata_lima2.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: blissdata-lima2
-Version: 2.0
+Version: 2.0.2
 Summary: Lima2 plugin for blissdata
 Maintainer: BCU (ESRF)
 License-Expression: MIT
+Project-URL: Repository, https://gitlab.esrf.fr/bliss/blissdata-lima2
 Keywords: blissdata,lima2
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
@@ -11,11 +12,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: blissdata~=2.3
-Requires-Dist: lima2-client~=4.0
+Requires-Dist: lima2-client~=4.1
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-redis; extra == "dev"
 Dynamic: license-file
 

{blissdata_lima2-2.0 → blissdata_lima2-2.0.2}/src/blissdata_lima2.egg-info/requires.txt

@@ -1,8 +1,10 @@
 blissdata~=2.3
-lima2-client~=4.0
+lima2-client~=4.1
 
 [dev]
 black
 flake8
+mypy
 pytest
+pytest-cov
 pytest-redis

blissdata_lima2-2.0/src/blissdata_lima2/tests/test_lima2_stream.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This file is part of the bliss project
-#
-# Copyright (c) Beamline Control Unit, ESRF
-# Distributed under the GNU LGPLv3. See LICENSE for more info.
-
-"""Unit test suite for Lima2 stream and view (streams/lima2.py)."""
-
-from unittest.mock import Mock, call
-from uuid import uuid1
-
-import numpy as np
-import pytest
-from blissdata.exceptions import IndexNotYetThereError
-from blissdata.lima.image_utils import ImageData
-from blissdata.streams import EventStream
-
-from blissdata_lima2 import Lima2Stream, Lima2View
-from blissdata_lima2.stream import get_frame
-
-
-def test_lima2_get_frame():
-    services = Mock()
-    uuid = str(uuid1())
-    frm = get_frame(services=services, acq_uuid=uuid, source="cafe", frame_idx=123)
-    services.pipeline.get_frame.assert_called_with(
-        frame_idx=123, source="cafe", uuid=uuid
-    )
-    assert type(frm) is ImageData
-
-
-def test_lima2_view():
-    services = Mock()
-    uuid = str(uuid1())
-    view = Lima2View(
-        services=services,
-        acq_uuid=uuid,
-        source="cafe",
-        start=0,
-        stop=42,
-    )
-    assert len(view) == 42
-    assert view.index == 0
-
-    frames = view.get_data()
-    assert len(frames) == len(view)
-
-    services.pipeline.get_frame.assert_has_calls(
-        [call(uuid=uuid, source="cafe", frame_idx=i) for i in range(42)]
-    )
-
-
-def test_lima2_protocol(data_store):
-    uuid = str(uuid1())
-
-    stream_def = Lima2Stream.make_definition(
-        name="device:cafe",
-        source_name="cafe",
-        conductor_hostname="www.lima2.org",
-        conductor_port=12345,
-        acq_uuid=uuid,
-        master_file=None,
-        dtype=np.float128,  # fat pixels >:)
-        shape=(4, 1024, 512),
-    )
-    model = data_store._stream_model(
-        encoding=stream_def.encoder.info(), info=stream_def.info
-    )
-    model.info["protocol_version"] = 1  # hack the protocol number
-    event_stream = EventStream.create(data_store, stream_def.name, model)
-
-    with pytest.raises(RuntimeError):
-        _ = Lima2Stream(event_stream=event_stream)
-
-
-def test_lima2_stream(data_store, monkeypatch):
-    uuid = str(uuid1())
-
-    stream_def = Lima2Stream.make_definition(
-        name="device:cafe",
-        source_name="cafe",
-        conductor_hostname="www.lima2.org",
-        conductor_port=12345,
-        acq_uuid=uuid,
-        master_file=None,
-        dtype=np.float128,  # fat pixels >:)
-        shape=(4, 1024, 512),
-    )
-    model = data_store._stream_model(
-        encoding=stream_def.encoder.info(), info=stream_def.info
-    )
-
-    event_stream = EventStream.create(data_store, stream_def.name, model)
-    stream = Lima2Stream(event_stream=event_stream)
-
-    assert stream.plugin == "lima2"
-    assert stream.shape == stream_def.info["shape"]
-
-    # Feed the event stream
-    event_stream.send(np.uint32(42))
-    event_stream.join()
-    assert len(stream) == 42
-
-    event_stream.send(np.uint32(123))
-    event_stream.join()
-    assert len(stream) == 123
-
-    mock_get_frame = Mock()
-    monkeypatch.setattr("blissdata_lima2.stream.get_frame", mock_get_frame)
-
-    # Indexing
-    _ = stream[0]
-    mock_get_frame.assert_called_with(
-        services=stream._services,
-        acq_uuid=uuid,
-        source="cafe",
-        frame_idx=0,
-    )
-
-    with pytest.raises(IndexNotYetThereError):
-        _ = stream[-1]
-
-    # Slicing
-    _ = stream[:3]
-    assert mock_get_frame.mock_calls[-3:] == [
-        call(services=stream._services, acq_uuid=uuid, source="cafe", frame_idx=0),
-        call(services=stream._services, acq_uuid=uuid, source="cafe", frame_idx=1),
-        call(services=stream._services, acq_uuid=uuid, source="cafe", frame_idx=2),
-    ]
-
-    with pytest.raises(IndexNotYetThereError):
-        _ = stream[-2:]
-
-    with pytest.raises(IndexNotYetThereError):
-        _ = stream[:-2]
-
-    event_stream.seal()
-    event_stream.join()
-
-    # Now slicing/indexing from end is ok
-    _ = stream[-2:]
-    assert mock_get_frame.mock_calls[-2:] == [
-        call(
-            services=stream._services,
-            acq_uuid=uuid,
-            source="cafe",
-            frame_idx=123 - 2,
-        ),
-        call(
-            services=stream._services,
-            acq_uuid=uuid,
-            source="cafe",
-            frame_idx=123 - 1,
-        ),
-    ]
-
-    _ = stream[-3]
-    assert mock_get_frame.mock_calls[-1] == call(
-        services=stream._services,
-        acq_uuid=uuid,
-        source="cafe",
-        frame_idx=123 - 3,
-    )
-
-    _ = stream[:]
-    assert mock_get_frame.mock_calls[-123:] == [
-        call(services=stream._services, acq_uuid=uuid, source="cafe", frame_idx=i)
-        for i in range(123)
-    ]
-
-    _ = stream.get_last_live_image()
-    mock_get_frame.assert_called_with(
-        services=stream._services,
-        acq_uuid=uuid,
-        source="cafe",
-        frame_idx=-1,
-    )