lima2.client 4.0.7__tar.gz → 4.0.8__tar.gz

{lima2_client-4.0.7/src/lima2_client.egg-info → lima2_client-4.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lima2-client
-Version: 4.0.7
+Version: 4.0.8
 Summary: Python client library for Lima2 detector
 Author: BCU (ESRF)
 License-Expression: MIT

{lima2_client-4.0.7 → lima2_client-4.0.8}/src/lima2/common/devencoded/dense_frame.py

@@ -125,7 +125,7 @@ def decode(raw_data: EncodedFrame) -> Frame:
     except Exception:
         raise DevEncodedFormatNotSupported(
             "Image format from Lima Tango device not supported (found %s)." % data_type
-        )
+        ) from None
     if endianness != 0:
         raise DevEncodedFormatNotSupported(
             "Unsupported endianness (found %s)." % endianness
@@ -139,7 +139,9 @@ def decode(raw_data: EncodedFrame) -> Frame:
     try:
         dtype = MODE_TO_NUMPY[mode]
     except Exception:
-        raise DevEncodedFormatNotSupported("Data format %s is not supported" % mode)
+        raise DevEncodedFormatNotSupported(
+            "Data format %s is not supported" % mode
+        ) from None
 
     data = numpy.frombuffer(raw_data, offset=header_size, dtype=dtype)
     data.shape = dim3, dim2, dim1

{lima2_client-4.0.7 → lima2_client-4.0.8}/src/lima2/conductor/acquisition.py

@@ -10,15 +10,25 @@ Contains state logic for running acquisitions.
 
 import asyncio
 import logging
+import time
 import traceback
+import weakref
 from dataclasses import dataclass
 from enum import Enum, auto
 from typing import Awaitable, Callable
-from uuid import UUID
-import weakref
-
-from lima2.conductor.processing.pipeline import Pipeline
 
+from lima2.common.exceptions import Lima2BackendError
+from lima2.common.types import FrameInfo
+from lima2.conductor.processing import pipeline_classes
+from lima2.conductor.processing.master_file import (
+    FrameSavingChannel,
+    MasterFileMetadata,
+)
+from lima2.conductor.processing.reduced_data import RoiParams
+from lima2.conductor.tango.container import TangoProcessingGroup
+from lima2.conductor.tango.processing import ProcessingErrorEvent, TangoProcessing
+from lima2.conductor.tango.utils import format_exception
+from lima2.conductor.utils import naturaltime
 
 logger = logging.getLogger(__name__)
 
@@ -171,17 +181,6 @@ class AcquisitionState:
         await self.event_queue.put((event, fut))
         return fut
 
-    async def process(self, event: AcquisitionEvent) -> None:
-        """Enqueue an event and wait for it to be processed.
-
-        If other events are already in the queue, they will be processed first.
-
-        The returned future can be awaited to pause until the event has been
-        processed.
-        """
-        fut = await self.enqueue(event=event)
-        await fut
-
     async def _handle(self, event: AcquisitionEvent) -> list[AcquisitionEvent]:
         """Handle an event.
 
@@ -295,32 +294,58 @@ class AcquisitionState:
                         f"Error while handling {evt}: {traceback.format_exc()}"
                     )
                     fut.set_exception(e)
-                finally:
-                    # NOTE: break condition
-                    if evt is AcquisitionEvent.FINISHED:
-                        break
+
+                # NOTE: break condition
+                if evt is AcquisitionEvent.FINISHED:
+                    break
 
 
 class Acquisition:
-    """
-    A prepared acquisition, listening to events from the control and receiver devices,
-    and, optionally, from the processing devices.
+    """Prepared acquisition, ready to start.
+
+    Holds an internal state, a set of processing devices, and a Pipeline instance.
+
+    Listens to events from all devices in order to update its state and properly manage
+    local tasks.
     """
 
     def __init__(
         self,
-        uuid: UUID,
-        num_receivers: int,
+        processing_devices: TangoProcessingGroup,
         on_end: OnEndCallback,
         on_failure: OnFailureCallback,
+        num_frames: int,
+        frame_infos: dict[str, FrameInfo],
+        roi_params: RoiParams,
+        saving_channels: dict[str, FrameSavingChannel],
+        masterfile_metadata: MasterFileMetadata,
     ) -> None:
-        self.uuid = uuid
+        self.uuid = processing_devices.uuid
         self.state = AcquisitionState(
-            num_receivers=num_receivers,
+            num_receivers=len(processing_devices),
             on_end=on_end,
             on_failure=on_failure,
         )
-        self.pipeline: Pipeline | None = None
+        self.proc_group = processing_devices
+        """Processing device group."""
+
+        # Instantiate a Pipeline
+        pipeline_class = pipeline_classes[self.proc_group.class_name]
+        self.pipeline = pipeline_class(
+            devices=processing_devices,
+            num_frames=num_frames,
+            frame_infos=frame_infos,
+            roi_params=roi_params,
+            saving_channels=saving_channels,
+            masterfile_metadata=masterfile_metadata,
+        )
+        """Processing pipeline."""
+
+        self.processing_errors: list[str] = []
+        """Holds processing error messages that occurred during the run, if any."""
+
+        self.done_devices: set[TangoProcessing] = set()
+        """Set of processing devices that have finished (successfully or not)."""
 
     def __del__(self) -> None:
         logger.debug(f"Acquisition instance {self.uuid} destroyed")
@@ -333,45 +358,110 @@ class Acquisition:
 
     def start(self) -> None:
         """Start the pipeline subtasks and listen for device events."""
-        if self.pipeline is None:
-            raise RuntimeError(f"Pipeline is not attached for acquisition {self.uuid}")
-
         self.pipeline.start()
         self.state.start()
 
-    async def attach(self, pipeline: Pipeline) -> None:
-        """Register handlers to a pipeline's events."""
-        self.pipeline = pipeline
+    @staticmethod
+    async def attach(
+        processing_devices: TangoProcessingGroup,
+        on_end: OnEndCallback,
+        on_failure: OnFailureCallback,
+        num_frames: int,
+        frame_infos: dict[str, FrameInfo],
+        roi_params: RoiParams,
+        saving_channels: dict[str, FrameSavingChannel],
+        masterfile_metadata: MasterFileMetadata,
+    ) -> "Acquisition":
+        """
+        Instantiate a complete Acquisition instance listening to processing device
+        events.
+        """
+        instance = Acquisition(
+            processing_devices=processing_devices,
+            on_end=on_end,
+            on_failure=on_failure,
+            num_frames=num_frames,
+            frame_infos=frame_infos,
+            roi_params=roi_params,
+            saving_channels=saving_channels,
+            masterfile_metadata=masterfile_metadata,
+        )
+
+        await instance.listen()
+
+        return instance
+
+    def detach(self) -> None:
+        """Stop listening to events."""
+        self.state.detach()
+
+    async def notify(self, event: AcquisitionEvent) -> None:
+        """Enqueue an event in the AcquisitionState and return."""
+        await self.state.enqueue(event=event)
+
+    async def listen(self) -> None:
+        """Listen to processing device events to update the AcquisitionState.
+
+        Should be called just after instantiating the Acquisition instance.
+        """
 
         # NOTE: Using weakref in event handlers is necessary to allow the
-        # garbage collector to destroy the Acquisition object.
+        # garbage collector to destroy the Pipeline object.
         # This is CRUCIAL for proper cleanup of the tango DeviceProxy
         # instances.
         # See https://gitlab.esrf.fr/limagroup/lima2-client/-/issues/90.
         wself = weakref.ref(self)
 
-        async def on_pipeline_finished() -> None:
+        async def on_device_finished(device: TangoProcessing) -> None:
+            """Adds a processing device to the done_devices set.
+
+            When the set is complete, call the on_finished callback registered to
+            this pipeline instance (see constructor).
+            """
+            logger.info(f"Processing device {device.name} is done")
+
             self_ref = wself()
-            if not self_ref:
+            if self_ref is None:
                 return
+
             await self_ref.notify(event=AcquisitionEvent.PROC_DEVICE_DONE)
 
-        async def on_pipeline_error() -> None:
+            self_ref.done_devices.add(device)
+            if self_ref.done_devices == set(self_ref.proc_group):
+                logger.info("Closing pipeline")
+                await self_ref.pipeline.close()
+
+        async def on_device_error(evt: ProcessingErrorEvent) -> None:
+            """Reports a processing error to the registered callback."""
             self_ref = wself()
-            if not self_ref:
+            if self_ref is None:
                 return
+
+            err_msg = format_exception(
+                where=evt.device_name,
+                when="while processing frames",
+                what=evt.what,
+                info=evt.info,
+            )
+            logger.warning(err_msg)
+            self_ref.processing_errors.append(err_msg)
+
             await self_ref.notify(event=AcquisitionEvent.PROC_DEVICE_FAILED)
 
-        await self.pipeline.attach(
-            on_finished=on_pipeline_finished, on_error=on_pipeline_error
+        reg_t0 = time.perf_counter()
+
+        results = await self.proc_group.listen(
+            on_finished=on_device_finished, on_error=on_device_error
         )
 
-    def detach(self) -> None:
-        """Stop listening to events."""
-        self.state.detach()
-        if self.pipeline is not None:
-            self.pipeline.unregister()
+        errors = [res for res in results if res is not None]
+        if len(errors) > 0:
+            raise Lima2BackendError(
+                "Couldn't register event handlers on some processing devices:\n- "
+                + "\n- ".join([str(err) for err in errors])
+            )
 
-    async def notify(self, event: AcquisitionEvent) -> None:
-        """Enqueue an event in the AcquisitionState and return."""
-        await self.state.enqueue(event=event)
+        logger.info(
+            f"Registered to processing device events in "
+            f"{naturaltime(time.perf_counter() - reg_t0)}"
+        )