lima2.client 2.2.1__tar.gz → 3.0.0__tar.gz

{lima2_client-2.2.1/src/lima2_client.egg-info → lima2_client-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lima2-client
-Version: 2.2.1
+Version: 3.0.0
 Summary: Python client library for Lima2 detector
 Author: BCU (ESRF)
 License: Copyright (c) 2020-2024 Beamline Control Unit, ESRF
@@ -16,7 +16,7 @@ Project-URL: Documentation, https://limagroup.gitlab-pages.esrf.fr/lima2-client/
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytango
@@ -33,8 +33,10 @@ Requires-Dist: black==22.3; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: types-pyyaml; extra == "dev"
 Requires-Dist: types-jsonschema; extra == "dev"
+Requires-Dist: types-gevent; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
+Requires-Dist: nosqltangodb; extra == "dev"
 Requires-Dist: pytango-db; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-forked; extra == "dev"

{lima2_client-2.2.1 → lima2_client-3.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ version_scheme = "guess-next-dev"
 
 [project]
 name = "lima2-client"
-requires-python = ">= 3.9"
+requires-python = ">= 3.10"
 dynamic = ["version"]
 authors = [{ name = "BCU (ESRF)" }]
 description = "Python client library for Lima2 detector"
@@ -43,8 +43,10 @@ dev = [
     "mypy",
     "types-pyyaml",
     "types-jsonschema",
+    "types-gevent",
     "flake8",
     "ipython",
+    "nosqltangodb",
     "pytango-db",
     "pytest",
     "pytest-forked",

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/finite_state_machine/draw_state_diagram.py

@@ -3,7 +3,6 @@ import importlib
 import inspect
 import os
 import sys
-from typing import List
 
 from finite_state_machine.state_machine import TransitionDetails
 
@@ -28,7 +27,7 @@ def generate_state_diagram_markdown(cls, initial_state):
     """
 
     class_fns = inspect.getmembers(cls, predicate=inspect.isfunction)
-    state_transitions: List[TransitionDetails] = [
+    state_transitions: list[TransitionDetails] = [
         func._fsm for name, func in class_fns if hasattr(func, "_fsm")
     ]
 

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/finite_state_machine/state_machine.py

@@ -2,7 +2,7 @@ import asyncio
 from enum import Enum
 import functools
 import types
-from typing import NamedTuple, Union
+from typing import NamedTuple
 
 from .exceptions import ConditionsNotMet, InvalidStartState
 
@@ -17,10 +17,10 @@ class StateMachine:
 
 class TransitionDetails(NamedTuple):
     name: str
-    source: Union[list, bool, int, str]
-    target: Union[bool, int, str]
+    source: list | bool | int | str
+    target: bool | int | str
     conditions: list
-    on_error: Union[bool, int, str]
+    on_error: bool | int | str
 
 
 class transition:
@@ -95,11 +95,13 @@ class transition:
                 result = func(*args, **kwargs)
                 state_machine.state = self.target
                 return result
-            except Exception:
+            except Exception as e:
                 # TODO should we log this somewhere?
                 # logger.error? maybe have an optional parameter to set this up
                 # how to libraries log?
                 state_machine.state = self.on_error
+                if self.reraise:
+                    raise e
                 return
 
         @functools.wraps(func)

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/lima2/client/client.py

@@ -20,12 +20,12 @@ import logging
 import os
 import traceback
 from concurrent import futures
+from typing import Any
 from uuid import UUID
 
 import tango as tg
 import yaml
 from beartype import beartype
-from typing_extensions import Any, Optional
 
 from lima2.client import pipelines, progress_counter, state_machine, topology
 from lima2.client.detector import Detector
@@ -157,13 +157,33 @@ class Client:
             acq_params=acq_params,
             proc_params=proc_params,
             num_receivers=len(self.receivers),
+            topology_kind=self.topology_kind,
         )
 
         self.detector.prepare_acq(uuid, ctl, acq, proc)
 
+        def on_error(evt: tg.DataReadyEventData):
+            logger.error(
+                f"Pipeline {evt.device.dev_name()} failed.\n"
+                f"Reason: '{evt.device.last_error}'"
+            )
+            if str(self.current_pipeline.uuid) in evt.device.dev_name():
+                logger.info(
+                    f"Stopping current acquisition ({self.current_pipeline.uuid})..."
+                )
+                self.detector.abort_acq()
+
+        self.current_pipeline.register_on_error(on_error)
+
     @docstring_from(Detector.start_acq)
     def start_acq(self) -> None:
-        self.detector.start_acq()
+        pipeline = self.current_pipeline
+        pipeline.register_on_finished(pipeline.unregister_events)
+        try:
+            self.detector.start_acq()
+        except Exception:
+            pipeline.unregister_events()
+            raise
 
     @docstring_from(Detector.trigger)
     def trigger(self) -> None:
@@ -218,7 +238,7 @@ class Client:
             return []
         return [UUID(u) for u in {y for x in uuids for y in x}]
 
-    def pipeline(self, uuid: Optional[UUID] = None) -> Pipeline:
+    def pipeline(self, uuid: UUID | None = None) -> Pipeline:
         """Get a specific pipeline by uuid. Return the current one by default (uuid=None)"""
         if uuid is None:
             return self.current_pipeline
@@ -280,9 +300,14 @@ class Client:
 
         Raises if the pipeline is absent from a receiver.
         """
+
+        # First unregister Tango events
+        pipeline = self.__pipelines.pop(uuid, None)
+        if pipeline is not None:
+            pipeline.unregister_events()
+
         for recv in self.receivers:
             recv.erasePipeline(str(uuid))
-        self.__pipelines.pop(uuid, None)
 
     def clear_previous_pipelines(self) -> None:
         """Erase all pipelines except the current one."""
@@ -314,7 +339,7 @@ class Client:
                 try:
                     cleared = cleared.union(future.result())
                 except Exception:
-                    logger.warning(
+                    logger.info(
                         f"Exception while clearing pipelines from {receiver.dev_name()}: "
                         f"{traceback.format_exc()}"
                     )

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/lima2/client/detector.py

@@ -18,14 +18,18 @@ Typical usage example:
 
 from __future__ import annotations
 
+import contextlib
 import json
 import logging
 import uuid
+from collections.abc import Iterator
+
+import gevent
 
 import tango
 from beartype import beartype
+from gevent.lock import BoundedSemaphore
 from jsonschema_default import create_from
-from typing_extensions import Optional
 
 from lima2.client import pipelines
 from lima2.client import state_machine as fsm
@@ -78,9 +82,12 @@ class Detector:
                 f"Receiver MPI rank order does not match client order: {rank_order}"
             )
 
-        self.__params_schema: Optional[dict] = None
+        self.__params_schema: dict | None = None
         self.__fsm = fsm.StateMachine(self.__ctrl, self.__recvs)
-        self.__try_sync_hard()
+        self.__fsm_lock = BoundedSemaphore()
+
+        self._register_state_change_handlers()
+        self.sync_hard()
 
         if _logger.getEffectiveLevel() == logging.DEBUG:
             # Log transition of states
@@ -93,6 +100,14 @@ class Detector:
             d.set_green_mode(tango.GreenMode.Gevent)
             d.set_timeout_millis(timeout * 1000)
 
+    @contextlib.contextmanager
+    def _locked_fsm(self) -> Iterator[fsm.StateMachine]:
+        self.__fsm_lock.acquire()
+        try:
+            yield self.__fsm
+        finally:
+            self.__fsm_lock.release()
+
     @property
     def det_info(self) -> dict:
         """
@@ -313,18 +328,8 @@ class Detector:
         Group:
             State
         """
-        return self.__fsm.state
-
-    def __try_sync_hard(self):
-        """
-        Try to init the state from a lazy constructed device Proxy
-        (to be used when the DS is not running when Detector is constructed)
-        """
-        try:
-            self.ping()
-            self.sync_hard()
-        except tango.DevFailed:
-            return False
+        with self._locked_fsm() as fsm:
+            return fsm.state
 
     def sync_hard(self):
         """
@@ -333,12 +338,13 @@ class Detector:
         Group:
             State
         """
-        try:
-            self.__fsm.sync()
-        except Exception as e:
-            _logger.warning(f"Unable to sync with server: {e}")
+        with self._locked_fsm() as fsm:
+            try:
+                fsm.sync()
+            except Exception as e:
+                _logger.warning(f"Unable to sync with server: {e}")
 
-        return self.__fsm.state
+            return fsm.state
 
     @property
     def dev_states(self):
@@ -366,7 +372,8 @@ class Detector:
         Group:
             State
         """
-        self.__fsm.register_transition_logger(logger)
+        with self._locked_fsm() as fsm:
+            fsm.register_transition_logger(logger)
 
     def unregister_transition_logger(self, logger):
         """
@@ -378,7 +385,8 @@ class Detector:
         Group:
             State
         """
-        self.__fsm.unregister_transition_logger(logger)
+        with self._locked_fsm() as fsm:
+            fsm.unregister_transition_logger(logger)
 
     @beartype
     def prepare_acq(
@@ -400,12 +408,18 @@ class Detector:
             f"prepare_acq({uuid}, {ctrl_params}, {acq_params}, {proc_params})"
         )
 
-        validate(
-            instance=ctrl_params,
-            schema=self.params_schema[self.ctrl.name()]["acq_params"],
-        )
+        def parallel_exec(ctrl_fn, recv_fn):
+            tasks = [gevent.spawn(ctrl_fn, self.__ctrl)]
+            tasks += [gevent.spawn(recv_fn, i, r) for i, r in enumerate(self.__recvs)]
+            gevent.joinall(tasks, raise_error=True)
 
-        for i, recv in enumerate(self.__recvs):
+        def validate_ctrl(ctrl):
+            validate(
+                instance=ctrl_params,
+                schema=self.params_schema[ctrl.name()]["acq_params"],
+            )
+
+        def validate_recv(i, recv):
             validate(
                 instance=acq_params[i],
                 schema=self.params_schema[recv.name()]["acq_params"],
@@ -414,16 +428,22 @@ class Detector:
             pipeline_class = pipelines.get_class(proc_params[i]["class_name"])
             validate(instance=proc_params[i], schema=pipeline_class.params_schema)
 
+        parallel_exec(validate_ctrl, validate_recv)
+
         # Update parameters on the device servers
-        # TODO: Rename acq_params to ctrl_params
-        self.__ctrl.acq_params = json.dumps(ctrl_params)
-        for i, recv in enumerate(self.__recvs):
+        def update_ctrl(ctrl):
+            # TODO: Rename acq_params to ctrl_params
+            ctrl.acq_params = json.dumps(ctrl_params)
+
+        def update_recv(i, recv):
             recv.acq_params = json.dumps(acq_params[i])
             recv.proc_params = json.dumps(proc_params[i])
 
-        res = self.__fsm.prepare(str(uuid))
+        parallel_exec(update_ctrl, update_recv)
 
-        return res.get()  # Makes prepare_acq() synchronous
+        # Raises and reverts to IDLE on exception
+        with self._locked_fsm() as fsm:
+            fsm.prepare(str(uuid))
 
     def start_acq(self):
         """Start acquisition.
@@ -431,7 +451,11 @@ class Detector:
         Group:
             Control
         """
-        self.__fsm.start()
+
+        self._register_on_end_acq_handlers()
+
+        with self._locked_fsm() as fsm:
+            fsm.start()
 
     def trigger(self):
         """Software trigger.
@@ -439,7 +463,11 @@ class Detector:
         Group:
             Control
         """
-        self.__fsm.trigger()
+        with self._locked_fsm() as fsm:
+            if fsm.state == State.FAULT:
+                _logger.warning("Got trigger() while in FAULT state -> ignoring")
+            else:
+                fsm.trigger()
 
     def stop_acq(self):
         """
@@ -448,7 +476,9 @@ class Detector:
         Group:
             Control
         """
-        self.__fsm.stop()
+        with self._locked_fsm() as fsm:
+            fsm.stop()
+            fsm.close()
 
     def reset_acq(self):
         """
@@ -457,7 +487,18 @@ class Detector:
         Group:
             Control
         """
-        self.__fsm.reset_acq()
+        with self._locked_fsm() as fsm:
+            fsm.reset_acq()
+
+    def abort_acq(self):
+        """
+        Abort current acquisition (call Stop on running devices) and go to FAULT state.
+
+        Group:
+            Control
+        """
+        with self._locked_fsm() as fsm:
+            fsm.abort()
 
     @property
     def ctrl_params(self):
@@ -532,3 +573,122 @@ class Detector:
     #         yield self.get_processing(self, uuid)
     #     finally:
     #         self.erase_processing(uuid)
+
+    def _register_state_change_handlers(self):
+        """Register a "change of acq_state" callback on each device.
+
+        These handlers are responsible for handling receivers entering FAULT state
+        (e.g. when the pipeline throws an exception), and for setting the global state
+        to DISCONNECTED if we receive errors on the tango event channel.
+        """
+
+        disconnected_devices = set()
+
+        def on_acq_state_change(evt: tango.EventData):
+            """Handler for state changes of each individual device"""
+            nonlocal disconnected_devices
+
+            # Handle disconnect
+            if evt.err:
+                if evt.device not in disconnected_devices:
+                    _logger.error(
+                        f"Lost connection to device {evt.device.dev_name()}:\n"
+                        + "\n".join([f"- {err.desc}" for err in evt.errors])
+                        + "\n"
+                    )
+                disconnected_devices.add(evt.device)
+                with self._locked_fsm() as fsm:
+                    fsm.disconnect()
+                return
+
+            # Handle FAULT
+            AcqState = type(evt.device.acq_state)
+            acq_state = AcqState(evt.attr_value.value)
+            _logger.debug(f"{evt.device.dev_name()} changed state to {acq_state.name}")
+
+            if acq_state == AcqState.fault:
+                _logger.error(
+                    f"Device {evt.device.dev_name()} in FAULT state.\n"
+                    f"Reason: '{evt.device.last_error}'\n"
+                )
+                if self.state not in [State.FAULT, State.UNKNOWN]:
+                    _logger.error("Aborting acquisition.")
+                    with self._locked_fsm() as fsm:
+                        fsm.abort()
+
+            # Handle reconnect
+            if evt.device in disconnected_devices:
+                _logger.info(f"{evt.device.dev_name()} seems back up")
+                disconnected_devices.remove(evt.device)
+
+            if self.state == State.DISCONNECTED:
+                _logger.info("Trying to sync...")
+                with self._locked_fsm() as fsm:
+                    try:
+                        fsm.sync()
+                        disconnected_devices = set()
+                        print("Lima2 reconnected.")
+                    except Exception as e:
+                        _logger.warning(f"Sync failed: {e}")
+                    finally:
+                        _logger.info(f"Current state: {fsm.state}")
+
+        for dev in self.devs:
+            dev.subscribe_event(
+                "acq_state",
+                tango.EventType.CHANGE_EVENT,
+                on_acq_state_change,
+            )
+
+    def _register_on_end_acq_handlers(self):
+        """Register an "end of acquisition" callback on each receiver.
+
+        This handler callback is responsible for calling Close on the control device when
+        all receivers are finished transferring frames.
+        """
+        nb_frames_xferreds = []
+        event_ids = {}
+
+        def on_end_acq(evt):
+            nonlocal nb_frames_xferreds
+
+            # Filter spurious error events (if the device is restarted)
+            if evt.err:
+                _logger.error(
+                    f"Error on {evt.device.dev_name()} 'nb_frames_xferred' event:\n"
+                    + "\n".join([f"- {err.desc}" for err in evt.errors])
+                    + "\n"
+                )
+                for r, e in event_ids.items():
+                    r.unsubscribe_event(e)
+                return
+
+            nb_frames_xferreds.append(evt)
+
+            if len(nb_frames_xferreds) == len(self.recvs):
+                for r, e in event_ids.items():
+                    r.unsubscribe_event(e)
+
+                _logger.debug(f"on_end_acq while {self.state}")
+                with self._locked_fsm() as fsm:
+                    if fsm.state == State.RUNNING:
+                        fsm.close()
+                    elif fsm.state == State.FAULT:
+                        # Acquisition aborted -> do nothing
+                        pass
+                    else:
+                        # Unexpected
+                        _logger.info(f"Acquisition ended while in state {fsm.state}")
+
+                nb_frames_xferreds = []
+
+        # On server side, data_ready_event is pushed by each receiver
+        # at the end of the acquisition loop.
+        event_ids = {
+            r: r.subscribe_event(
+                "nb_frames_xferred",
+                tango.EventType.DATA_READY_EVENT,
+                on_end_acq,
+            )
+            for r in self.recvs
+        }

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/lima2/client/devencoded/dense_frame.py

@@ -11,7 +11,6 @@ import struct
 from dataclasses import dataclass
 
 import numpy
-from typing_extensions import Union
 
 from .exception import DevEncodedFormatNotSupported
 
@@ -19,7 +18,7 @@ DATA_HEADER_FORMAT = "<IHHIIHHHHHHHHIIIIIIQ"
 DATA_MAGIC = struct.unpack(">I", b"DTAY")[0]
 DATA_HEADER_SIZE = struct.calcsize(DATA_HEADER_FORMAT)
 
-EncodedFrame = Union[bytes, tuple[str, bytes]]
+EncodedFrame = bytes | tuple[str, bytes]
 
 
 class IMAGE_MODES(enum.Enum):

{lima2_client-2.2.1 → lima2_client-3.0.0}/src/lima2/client/devencoded/smx_sparse_frame.py

@@ -8,7 +8,6 @@
 
 import struct
 import numpy as np
-import typing
 from dataclasses import dataclass
 
 from .exception import DevEncodedFormatNotSupported
@@ -28,7 +27,7 @@ class SmxSparseFrame:
     background_avg: np.ndarray
     background_std: np.ndarray
 
-    idx: typing.Optional[int]
+    idx: int | None
     """Index of the frame where 0 is the first frame"""
 
     shape: tuple[int, ...]