lima2.client 3.0a0__tar.gz → 3.1.0__tar.gz

{lima2_client-3.0a0/src/lima2_client.egg-info → lima2_client-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lima2-client
-Version: 3.0a0
+Version: 3.1.0
 Summary: Python client library for Lima2 detector
 Author: BCU (ESRF)
 License: Copyright (c) 2020-2024 Beamline Control Unit, ESRF
@@ -24,7 +24,7 @@ Requires-Dist: gevent
 Requires-Dist: jsonschema
 Requires-Dist: jsonschema-default
 Requires-Dist: beartype
-Requires-Dist: numpy
+Requires-Dist: numpy<2.3
 Requires-Dist: pyyaml
 Requires-Dist: typing-extensions
 Requires-Dist: h5py

{lima2_client-3.0a0 → lima2_client-3.1.0}/pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
     "jsonschema",
     "jsonschema-default",
     "beartype",
-    "numpy",
+    "numpy<2.3",          # CI runner (CentOS 7) has glibc2.17, numpy>=2.3 needs glibc2.28+
     "pyyaml",
     "typing-extensions",
     "h5py",

{lima2_client-3.0a0 → lima2_client-3.1.0}/src/lima2/client/client.py

@@ -34,6 +34,8 @@ from lima2.client.progress_counter import ProgressCounter, SingleCounter
 from lima2.client.topology import TopologyKind
 from lima2.client.utils import docstring_from
 
+from lima2.master_file import generate as mfg
+
 logger = logging.getLogger(__name__)
 
 
@@ -77,6 +79,32 @@ class Client:
 
         self._tango_db = tg.Database()
 
+        # Show master file generation info messages
+        mfg.logger.setLevel(logging.INFO)
+
+        self.master_file_tasks: dict[UUID, dict[str, mfg.MasterFileTask]] = {}
+        """Master file generation tasks for each pipeline UUID.
+
+        Each entry corresponds to a pipeline, and holds a dict structured like
+        {saving channel name: list of tasks}.
+        """
+
+    def cleanup(self):
+        """Unregister all state loggers and tango event handlers.
+
+        This method serves only in specific cases where event handlers must for
+        some reason be unregistered. In a normal use case, a Client is
+        instantiated once per Lima2 instance, and no cleanup is necessary.
+
+        NOTE: After this call, the Client instance should no longer be used.
+        """
+        self._detector.unregister_events()
+        self._detector = None
+
+        for pipeline in self.__pipelines.values():
+            pipeline.unregister_events()
+        self.__pipelines.clear()
+
     @classmethod
     def from_yaml(
         cls,
@@ -147,16 +175,30 @@ class Client:
     ####################################################################################
 
     def prepare_acq(
-        self, uuid: UUID, ctrl_params: dict, acq_params: dict, proc_params: dict
+        self,
+        uuid: UUID,
+        ctrl_params: dict,
+        acq_params: dict,
+        proc_params: dict,
     ) -> None:
         """Prepare acquisition with a given uuid and set of params."""
 
+        # Check parameters required for master file generation
+        checked_params = mfg.check_generation(
+            ctrl_params=ctrl_params,
+            recv_params=acq_params,
+            proc_params=proc_params,
+            topology_kind=self.topology_kind,
+        )
+        ctrl_params, acq_params, proc_params = checked_params
+
         # Adjust params for distributed acquisition
         ctl, acq, proc = topology.distribute_acq(
             ctl_params=ctrl_params,
             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)
@@ -174,9 +216,40 @@ class Client:
 
         self.current_pipeline.register_on_error(on_error)
 
+        # Remove master file tasks of previous acquisitions if done or not started
+        for prev_uuid in list(self.master_file_tasks.keys()):
+            tasks = self.master_file_tasks[prev_uuid].values()
+            if all([not task.started() or task.ready() for task in tasks]):
+                logger.debug(
+                    "All master file tasks done (or never started) for "
+                    f"{prev_uuid} -> cleaning up"
+                )
+                self.master_file_tasks.pop(prev_uuid)
+            else:
+                logger.debug(f"Not all master file tasks done for {prev_uuid}...")
+
+        self.master_file_tasks[uuid] = mfg.enable_generation(
+            pipeline=self.current_pipeline,
+            num_frames=ctrl_params["acq"]["nb_frames"],
+            ctrl_params=ctl,
+            recv_params=acq[0],
+            proc_params=proc[0],
+            topology_kind=self.topology_kind,
+        )
+
     @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
+
+        for task in self.master_file_tasks[self.current_pipeline.uuid].values():
+            task.start()
 
     @docstring_from(Detector.trigger)
     def trigger(self) -> None:
@@ -293,9 +366,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."""

{lima2_client-3.0a0 → lima2_client-3.1.0}/src/lima2/client/detector.py

@@ -24,6 +24,8 @@ import logging
 import uuid
 from collections.abc import Iterator
 
+import gevent
+
 import tango
 from beartype import beartype
 from gevent.lock import BoundedSemaphore
@@ -71,6 +73,7 @@ class Detector:
 
         self.__ctrl = ctrl_dev
         self.__recvs = list(recv_devs)
+        self._state_event_ids: dict[tango.DeviceProxy, int] = {}
 
         self.ping()
 
@@ -98,6 +101,17 @@ class Detector:
             d.set_green_mode(tango.GreenMode.Gevent)
             d.set_timeout_millis(timeout * 1000)
 
+    def unregister_events(self):
+        """Unregister all state loggers and tango event handlers.
+
+        This method serves only in specific cases where event handlers must for
+        some reason be unregistered. In a normal use case, a Client is
+        instantiated once per Lima2 instance, and no cleanup is necessary.
+        """
+        for device, event_id in self._state_event_ids.items():
+            device.unsubscribe_event(event_id)
+        self._state_event_ids.clear()
+
     @contextlib.contextmanager
     def _locked_fsm(self) -> Iterator[fsm.StateMachine]:
         self.__fsm_lock.acquire()
@@ -406,12 +420,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)
+
+        def validate_ctrl(ctrl):
+            validate(
+                instance=ctrl_params,
+                schema=self.params_schema[ctrl.name()]["acq_params"],
+            )
 
-        for i, recv in enumerate(self.__recvs):
+        def validate_recv(i, recv):
             validate(
                 instance=acq_params[i],
                 schema=self.params_schema[recv.name()]["acq_params"],
@@ -420,13 +440,19 @@ 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])
 
+        parallel_exec(update_ctrl, update_recv)
+
         # Raises and reverts to IDLE on exception
         with self._locked_fsm() as fsm:
             fsm.prepare(str(uuid))
@@ -619,12 +645,14 @@ class Detector:
                     finally:
                         _logger.info(f"Current state: {fsm.state}")
 
-        for dev in self.devs:
-            dev.subscribe_event(
+        self._state_event_ids = {
+            dev: dev.subscribe_event(
                 "acq_state",
                 tango.EventType.CHANGE_EVENT,
                 on_acq_state_change,
             )
+            for dev in self.devs
+        }
 
     def _register_on_end_acq_handlers(self):
         """Register an "end of acquisition" callback on each receiver.