blissdata-lima2 2.0.1__tar.gz

blissdata_lima2-2.0.1/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2020-2024 Beamline Control Unit, ESRF
+
+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.

blissdata_lima2-2.0.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: blissdata-lima2
+Version: 2.0.1
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: blissdata~=2.3
+Requires-Dist: lima2-client~=4.0
+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
+
+Lima2 plugin for blissdata.

blissdata_lima2-2.0.1/README.md

@@ -0,0 +1,3 @@
+## blissdata-lima2
+
+Lima2 plugin for blissdata.

blissdata_lima2-2.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blissdata-lima2"
+version = "2.0.1"
+description = "Lima2 plugin for blissdata"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.md"]
+maintainers = [{ name = "BCU (ESRF)" }]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["blissdata", "lima2"]
+requires-python = ">=3.10"
+dependencies = ["blissdata~=2.3", "lima2-client~=4.0"]
+
+[project.urls]
+Repository = "https://gitlab.esrf.fr/bliss/blissdata-lima2"
+
+[project.optional-dependencies]
+dev = ["black", "flake8", "mypy", "pytest", "pytest-cov", "pytest-redis"]
+
+[project.entry-points.blissdata]
+lima2 = "blissdata_lima2"

blissdata_lima2-2.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

blissdata_lima2-2.0.1/src/blissdata_lima2/__init__.py

@@ -0,0 +1,4 @@
+from .stream import Lima2Stream, Lima2View  # noqa: F401
+
+stream_cls = Lima2Stream
+view_cls = Lima2View

blissdata_lima2-2.0.1/src/blissdata_lima2/stream.py

@@ -0,0 +1,349 @@
+# -*- 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.
+
+import logging
+from collections.abc import Sequence
+
+import lima2.client.services as l2s
+import numpy as np
+from blissdata.exceptions import (
+    EmptyViewException,
+    EndOfStream,
+    IndexNoMoreThereError,
+    IndexNotYetThereError,
+    IndexWontBeThereError,
+)
+from blissdata.h5api import dynamic_hdf5
+from blissdata.lima.image_utils import ImageData
+from blissdata.streams import (
+    BaseStream,
+    BaseView,
+    EventRange,
+    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
+
+_logger = logging.getLogger(__name__)
+
+
+def get_frame(
+    services: l2s.ConductorServices,
+    acq_uuid: str,
+    source: str,
+    frame_idx: int,
+) -> ImageData:
+    frm = services.pipeline.get_frame(frame_idx=frame_idx, source=source, uuid=acq_uuid)
+
+    if isinstance(frm, SparseFrame):
+        frm = frm.densify()
+
+    return ImageData(array=frm.data, frame_id=frm.idx, acq_tag=None)
+
+
+class Lima2View(BaseView):
+    def __init__(
+        self,
+        services: l2s.ConductorServices,
+        acq_uuid: str,
+        source: str,
+        start: int,
+        stop: int,
+    ) -> None:
+        self._services = services
+        """Lima2 client services."""
+        self._acq_uuid = acq_uuid
+        """Lima2 acquisition id."""
+        self._source = source
+        """Frame source name."""
+        self._idx_range = range(start, stop)
+        """Range of absolute frame indices accessible via this view."""
+
+    @property
+    def index(self) -> int:
+        return self._idx_range.start
+
+    def __len__(self) -> int:
+        return len(self._idx_range)
+
+    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
+                )
+            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):
+    """Stream of Lima2 frames.
+
+    Frames don't actually transit inside the stream. The stream length can be
+    queried to determine the number of accessible frames.
+
+    Indexing or slicing the stream attempts to fetch frames directly from the
+    Lima2 backend.
+    """
+
+    PROTOCOL_VERSION = 2
+
+    def __init__(self, event_stream: EventStream) -> None:
+        BaseStream.__init__(self, event_stream)
+
+        _logger.debug(f"Instantiate Lima2Stream with {event_stream.info=}")
+
+        if event_stream.info["protocol_version"] != Lima2Stream.PROTOCOL_VERSION:
+            raise RuntimeError(
+                f"Lima2 protocol version mismatch "
+                f"(expected {Lima2Stream.PROTOCOL_VERSION}, "
+                f"got {event_stream.info['protocol_version']})"
+            )
+
+        self._dtype = np.dtype(event_stream.info["dtype"])
+        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"]),
+            port=int(event_stream.info["conductor_port"]),
+        )
+        """Lima2 client session."""
+
+        self._length = 0
+        """Current number of accessible frames."""
+
+        self._cursor = Stream(event_stream).cursor()
+
+    ####################################################################################
+    # BaseStream
+    ####################################################################################
+
+    @property
+    def kind(self) -> str:
+        return "array"
+
+    @staticmethod
+    def make_definition(
+        name: str,
+        source_name: str,
+        conductor_hostname: str,
+        conductor_port: int,
+        acq_uuid: str,
+        master_file: tuple[str, str] | None,
+        dtype: DTypeLike,
+        shape: Sequence[int],
+    ) -> StreamDefinition:
+        info = {
+            "plugin": "lima2",
+            "dtype": np.dtype(dtype).name,
+            "shape": shape,
+            "protocol_version": Lima2Stream.PROTOCOL_VERSION,
+            "acq_uuid": acq_uuid,
+            "source_name": source_name,
+            "conductor_hostname": conductor_hostname,
+            "conductor_port": conductor_port,
+            "master_file": master_file,
+        }
+
+        return StreamDefinition(name, info, NumericStreamEncoder(np.uint32))
+
+    @property
+    def plugin(self) -> str:
+        return "lima2"
+
+    @property
+    def dtype(self) -> np.dtype:
+        return self._dtype
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        return self._shape
+
+    def __len__(self) -> int:
+        try:
+            view = self._cursor.read(block=False, last_only=True)
+        except EndOfStream:
+            view = None
+
+        if view is not None:
+            last_status = view.get_data()[0]
+            self._length = int(last_status)
+        return self._length
+
+    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)
+
+        else:
+            raise TypeError(f"{type(key)}")
+
+    def _need_last_only(self, last_only: bool) -> bool:
+        # Lima2 event stream represents current progress
+        # -> only the latest one is relevant.
+        return True
+
+    def _build_view_from_events(
+        self, index: int, events: EventRange, last_only: bool
+    ) -> Lima2View:
+        """
+        Build a Lima2View to access a slice of frames which starts at `index`,
+        and ends at the most recent frame according to `events`.
+        """
+        _logger.debug(f"{self.name}: {index=} -> {events=}")
+
+        # events.data[-1] corresponds to the current number of contiguous frames
+        # accessible from the lima2 backend.
+        stop_idx = events.data[-1]
+
+        if stop_idx <= index:
+            # no new image despite new events
+            raise EmptyViewException
+
+        return Lima2View(
+            services=self._services,
+            acq_uuid=self._acq_uuid,
+            source=self._source,
+            start=stop_idx - 1 if last_only else index,
+            stop=stop_idx,
+        )
+
+    ####################################################################################
+    # LimaDirectAccess
+    ####################################################################################
+
+    def get_last_live_image(self) -> ImageData:
+        return get_frame(
+            services=self._services,
+            acq_uuid=self._acq_uuid,
+            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.1/src/blissdata_lima2/tests/conftest.py

@@ -0,0 +1 @@
+from blissdata.tests.conftest import redis_db, redis_url, data_store  # noqa F401

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

@@ -0,0 +1,448 @@
+# -*- 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
+
+
+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):
+    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.1/src/blissdata_lima2.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: blissdata-lima2
+Version: 2.0.1
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: blissdata~=2.3
+Requires-Dist: lima2-client~=4.0
+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
+
+Lima2 plugin for blissdata.

blissdata_lima2-2.0.1/src/blissdata_lima2.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.md
+README.md
+pyproject.toml
+src/blissdata_lima2/__init__.py
+src/blissdata_lima2/stream.py
+src/blissdata_lima2.egg-info/PKG-INFO
+src/blissdata_lima2.egg-info/SOURCES.txt
+src/blissdata_lima2.egg-info/dependency_links.txt
+src/blissdata_lima2.egg-info/entry_points.txt
+src/blissdata_lima2.egg-info/requires.txt
+src/blissdata_lima2.egg-info/top_level.txt
+src/blissdata_lima2/tests/__init__.py
+src/blissdata_lima2/tests/conftest.py
+src/blissdata_lima2/tests/test_lima2_stream.py

blissdata_lima2-2.0.1/src/blissdata_lima2.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blissdata_lima2-2.0.1/src/blissdata_lima2.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[blissdata]
+lima2 = blissdata_lima2

blissdata_lima2-2.0.1/src/blissdata_lima2.egg-info/requires.txt

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

blissdata_lima2-2.0.1/src/blissdata_lima2.egg-info/top_level.txt

@@ -0,0 +1 @@
+blissdata_lima2