blissdata-mosca 2.0.2__tar.gz

blissdata_mosca-2.0.2/.gitignore

@@ -0,0 +1,112 @@
+pixi.lock
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Ignore any hidden files from the project root
+/.*
+!.gitlab-ci.yml
+
+conda-bld/
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov*/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+report.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+doc/site/
+
+# mypy
+.mypy_cache/
+
+*.mprg

blissdata_mosca-2.0.2/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.5
+Name: blissdata-mosca
+Version: 2.0.2
+Requires-Python: <3.13,>=3.10
+Requires-Dist: blissdata
+Requires-Dist: h5py
+Requires-Dist: mosca-client
+Requires-Dist: numpy

blissdata_mosca-2.0.2/README.rst

@@ -0,0 +1,4 @@
+Blissdata Mosca
+===============
+
+Blissdata stream plugin for MOSCA MCA detectors.

blissdata_mosca-2.0.2/pyproject.toml

@@ -0,0 +1,31 @@
+[project.entry-points.blissdata]
+mosca = "blissdata_mosca"
+
+[project]
+name = "blissdata-mosca"
+requires-python = ">=3.10,<3.13"
+version = "2.0.2"
+
+dependencies = [
+    "numpy",
+    "h5py",
+    "blissdata",
+    "mosca_client"
+]
+
+[build-system]
+build-backend = "hatchling.build"
+requires = ["hatchling"]
+
+[tool.pixi.package]
+name = "blissdata-mosca"
+version = { workspace = true }
+
+[tool.pixi.package.build]
+backend = { name = "pixi-build-python", version = "0.*" }
+
+[tool.pixi.package.host-dependencies]
+hatchling = "==1.26.3"
+
+[tool.pixi.pypi-dependencies]
+blissdata_mosca = { path = ".", editable = true }

blissdata_mosca-2.0.2/src/blissdata_mosca/__init__.py

@@ -0,0 +1,4 @@
+from .stream import MoscaStream, MoscaView
+
+stream_cls = MoscaStream
+view_cls = MoscaView

blissdata_mosca-2.0.2/src/blissdata_mosca/stream.py

@@ -0,0 +1,297 @@
+import os
+from typing import NamedTuple
+from dataclasses import dataclass
+
+import numpy as np
+import h5py
+
+from blissdata.streams import BaseStream, BaseView, StreamDefinition
+from blissdata.streams.encoding.json import JsonStreamEncoder
+from blissdata.exceptions import (
+    EndOfStream,
+    IndexWontBeThereError,
+    IndexNotYetThereError,
+    IndexNoMoreThereError,
+    EmptyViewException,
+)
+
+from mosca_client.tango.mosca import Reader as MoscaReader
+
+
+PROTOCOL_VERSION = 1
+
+
+@dataclass
+class SpectraReference:
+    file_path: str
+    data_path: str | None
+    index: int
+
+
+class SpectraData(NamedTuple):
+    array: np.ndarray
+    """Numpy array containing data of this frame"""
+
+    frame_id: int | None
+    """Number of the frame (0=first frame) in a sequence of frames."""
+
+
+class MoscaStream(BaseStream):
+    PROTOCOL_VERSION = 1
+
+    def __init__(self, event_stream):
+        super().__init__(event_stream)
+
+        self._last_read_index = -1
+        self._last_saved_index = -1
+
+        info = event_stream.info
+        mosca_info = info["mosca_info"]
+
+        protocol = mosca_info["protocol_version"] 
+        if MoscaStream.PROTOCOL_VERSION != protocol:
+            raise Exception(
+                f"{type(self).__name__} supports mosca json protocol {MoscaStream.PROTOCOL_VERSION}, found version {protocol}"
+            )
+
+        self._points_per_file = mosca_info["points_per_file"]
+        self._file_path = mosca_info["file_path"]
+        self._file_prefix = mosca_info["file_prefix"]
+        self._data_path = mosca_info["data_path"]
+        self._dtype = info["dtype"]
+        self._shape = info["shape"]
+        self._data_index = info["data_index"]
+        self._detector = info["detector"]
+
+        self._reader = MoscaReader(
+            event_stream.info["mosca_info"]["server_url"],
+            acq_id=event_stream.info["mosca_info"]["acq_id"]
+        )
+
+    @property
+    def kind(self):
+        return "array"
+    
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def data_index(self):
+        return self._data_index
+
+    @staticmethod
+    def make_definition(name,
+                        detector,
+                        data_index,
+                        dtype,
+                        shape,
+                        tango_url,
+                        acq_id: int,
+                        saving={},
+                        info={}) -> StreamDefinition:
+        info = info.copy()
+        info["plugin"] = "mosca"
+        info["detector"] = detector
+        info["data_index"] = data_index
+        info["dtype"] = np.dtype(dtype).name
+        info["shape"] = shape
+        mosca_info = info.setdefault("mosca_info", {})
+
+        mosca_info["server_url"] = tango_url
+        mosca_info["acq_id"] = acq_id
+        mosca_info["protocol_version"] = MoscaStream.PROTOCOL_VERSION
+
+        if saving:
+            saving_keys = {
+                "file_path",
+                "data_path",
+                "file_format",
+                "file_prefix",
+                "points_per_file",
+            }
+            missing_keys = saving_keys - saving.keys()
+            extra_keys = saving.keys() - saving_keys
+            if missing_keys:
+                raise ValueError(
+                    f"The following keys are missing from 'saving' dict: {missing_keys}"
+                )
+            if extra_keys:
+                raise ValueError(
+                    f"The following keys are not expected in 'saving' dict: {extra_keys}"
+                )
+
+            mosca_info.update(saving)
+
+        return StreamDefinition(name, info, JsonStreamEncoder())
+
+    @property
+    def plugin(self):
+        return "mosca"
+
+    def __len__(self):
+        return self._reader.n_available_points
+
+    def __getitem__(self, key):
+        if self._last_read_index == -1:
+            self._update()
+
+        stop = None
+        if isinstance(key, int):
+            if key == -1:
+                return self.get_last_live_spectra()
+            start = key
+            stop = key + 1
+        elif isinstance(key, slice):
+            if key.step not in (1, None):
+                raise RuntimeError(f"slice.step not in (1, None)")
+            start = 0 if key.start is None else key.start
+            stop = self._last_read_index + 1 if key.stop in (-1, None) else key.stop
+        else:
+            raise TypeError(f"Invalid type for arg key: {type(key)}.")
+
+        data = self._read(start, stop)
+        return data
+
+    def _update(self):
+        last_event = self.event_stream[-1]
+        self._last_read_index = last_event["last_read_index"]
+        self._last_saved_index = last_event["last_saved_index"]
+
+    def _read(self, start, stop):
+        if stop - 1 <= self._last_saved_index:
+            data = self._get_from_files(start, stop)
+        elif start < self._last_saved_index:
+            file_data = self._get_from_files(start, self._last_saved_index + 1)
+            server_data = self._reader.read_spectra(self._last_saved_index + 1, stop)[self.data_index]
+            data = np.concatenate((file_data, server_data), axis=0)
+        else:
+            data = self._reader.read_spectra(start, stop)[self.data_index]
+        return data
+
+    def _get_from_files(self, start, stop):
+        n_points = stop - start
+
+        data = np.zeros((n_points, self.shape[-1]), self.dtype)
+
+        assert start < stop
+        data_path = f"{self._data_path}/spectra"
+
+        filenames, dset_idx = self._idx_to_files(start, stop)
+
+        data_idx = np.add.accumulate(np.diff(dset_idx, axis=1)[:, 0])
+        data_idx = np.concatenate(([0], data_idx))
+
+        for f_idx, filename in enumerate(filenames):
+            dset_0, dset_1 = dset_idx[f_idx]
+            data_0, data_1 = data_idx[f_idx:f_idx + 2]
+            with h5py.File(filename, "r") as h5f:
+                data[data_0:data_1, :] = h5f[data_path][self.data_index, dset_0:dset_1, :]
+
+        return data
+
+    def _idx_to_files(self, start, stop):
+        """ Given a range of points [start .. stop[, returns
+            a list of files containing those points,
+            along with the indices of those points within the files.
+            
+            Returns three objects:
+            - ordered list of N file names
+            - ordered list of N 2-tuples, dataset indices range within each file """
+
+        assert start < stop
+        assert start >= 0
+
+        ppf = self._points_per_file
+        basename = os.path.join(self._file_path, f"{self._file_prefix}spectra_")
+
+        # file indices, points interval within the returned data
+        file_idx, data_idx = np.unique(np.arange(start, stop) // ppf,
+                                       return_index=True)
+        filenames = [f"{basename}{f_idx:04d}.h5" for f_idx in file_idx]
+
+        n_points = stop - start
+        dset_idx = np.zeros((len(filenames), 2), dtype=int)
+
+        def _last(n):
+            if n >= ppf:
+                return ppf
+            return n
+
+        dset_idx[0][:] = [start % ppf, _last((start % ppf) + n_points)]
+        for i, idx in enumerate(data_idx[1:], start=1):
+            dset_idx[i][:] = [0, _last(n_points - idx)]
+
+        return filenames, dset_idx
+
+    def get_references(self, start, stop):
+        if self._last_read_index == -1:
+            self._update()
+
+        data_path = f"{self._data_path}/spectra_{self._detector:02d}"
+        files, dset_idx = self._idx_to_files(start, stop)
+
+        references = [SpectraReference(file, data_path, idx)
+                      for file, indices in zip(files, dset_idx)
+                      for idx in range(indices[0], indices[1])]
+
+        return references
+
+    def _need_last_only(self, last_only):
+        # mosca uses json stream as a status,
+        # last one is the only valuable status
+        # forcing True
+        return True
+
+    def _build_view_from_events(self, index, events, last_only):
+        # print("===> EVENT", index, events, last_only)
+        lri = events.data[-1]["last_read_index"]
+        lsi = events.data[-1]["last_saved_index"]
+        # n_spec = len(self)
+        if lri < index:
+            raise EmptyViewException
+        
+        if last_only:
+            start = lri
+        else:
+            start = index
+        self._last_read_index = lri
+        self._last_saved_index = lsi
+        return MoscaView(self, start, lri + 1)
+
+    def get_last_live_spectra(self):
+        print("R1", self.data_index)
+        if self._last_read_index == -1:
+            self._update()
+        index = self._last_read_index
+        data = self._reader.read_spectra(index, self._last_read_index + 1)[self.data_index, 0]
+        return SpectraData(array=data, frame_id=index)
+
+
+class MoscaView(BaseView):
+    def __init__(self, stream, start, stop):
+        self._client = stream
+        self._view_range = range(start, stop)
+
+    @property
+    def index(self):
+        return self._view_range.start
+
+    def __len__(self):
+        return len(self._view_range)
+
+    def get_data(self, start=None, stop=None):
+        trimmed_range = self._view_range[start:stop]
+        return self._client[trimmed_range.start : trimmed_range.stop]
+
+    def get_references(
+        self, start=None, stop=None
+    ) -> SpectraReference | list[SpectraReference]:
+        trimmed_range = self._view_range[start:stop]
+        return self._client.get_references(
+            trimmed_range.start, trimmed_range.stop
+        )