dls-dodal 1.46.0__py3-none-any.whl → 1.48.0__py3-none-any.whl

dodal/devices/oav/oav_detector.py

@@ -5,13 +5,20 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     LazyMock,
+    SignalR,
     StandardReadable,
+    derived_signal_r,
+    soft_signal_rw,
 )
-from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.areadetector.plugins.CAM import Cam
-from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
+from dodal.devices.oav.oav_parameters import (
+    DEFAULT_OAV_WINDOW,
+    OAVConfig,
+    OAVConfigBase,
+    OAVConfigBeamCentre,
+)
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
@@ -52,7 +59,10 @@ class ZoomController(StandardReadable, Movable[str]):
 
 
 class OAV(StandardReadable):
-    def __init__(self, prefix: str, config: OAVConfig, name: str = ""):
+    beam_centre_i: SignalR[int]
+    beam_centre_j: SignalR[int]
+
+    def __init__(self, prefix: str, config: OAVConfigBase, name: str = ""):
         self.oav_config = config
         self._prefix = prefix
         self._name = name
@@ -60,51 +70,40 @@ class OAV(StandardReadable):
         self.zoom_controller = ZoomController(f"{_bl_prefix}-EA-OAV-01:FZOOM:", name)
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
-
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
-            self.microns_per_pixel_x = create_r_hardware_backed_soft_signal(
-                float,
-                lambda: self._get_microns_per_pixel(Coords.X),
-            )
-            self.microns_per_pixel_y = create_r_hardware_backed_soft_signal(
-                float,
-                lambda: self._get_microns_per_pixel(Coords.Y),
-            )
-            self.beam_centre_i = create_r_hardware_backed_soft_signal(
-                int, lambda: self._get_beam_position(Coords.X)
+
+        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+
+        with self.add_children_as_readables():
+            self.microns_per_pixel_x = derived_signal_r(
+                self._get_microns_per_pixel,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.X],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
             )
-            self.beam_centre_j = create_r_hardware_backed_soft_signal(
-                int, lambda: self._get_beam_position(Coords.Y)
+            self.microns_per_pixel_y = derived_signal_r(
+                self._get_microns_per_pixel,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.Y],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
             self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
                 self._name,
             )
 
-        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
-
         super().__init__(name)
 
-    async def _read_current_zoom(self) -> str:
-        _zoom = await self.zoom_controller.level.get_value()
+    def _read_current_zoom(self, _zoom: str) -> str:
         return _get_correct_zoom_string(_zoom)
 
-    async def _get_microns_per_pixel(self, coord: int) -> float:
+    def _get_microns_per_pixel(self, zoom_level: str, size: int, coord: int) -> float:
         """Extracts the microns per x pixel and y pixel for a given zoom level."""
-        _zoom = await self._read_current_zoom()
+        _zoom = self._read_current_zoom(zoom_level)
         value = self.parameters[_zoom].microns_per_pixel[coord]
-        size = await self.sizes[coord].get_value()
         return value * DEFAULT_OAV_WINDOW[coord] / size
 
-    async def _get_beam_position(self, coord: int) -> int:
-        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
-        zoom level. """
-        _zoom = await self._read_current_zoom()
-        value = self.parameters[_zoom].crosshair[coord]
-        size = await self.sizes[coord].get_value()
-        return int(value * size / DEFAULT_OAV_WINDOW[coord])
-
     async def connect(
         self,
         mock: bool | LazyMock = False,
@@ -114,3 +113,52 @@ class OAV(StandardReadable):
         self.parameters = self.oav_config.get_parameters()
 
         return await super().connect(mock, timeout, force_reconnect)
+
+
+class OAVBeamCentreFile(OAV):
+    """OAV device that reads its beam centre values from a file. The config parameter
+    must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
+    centre values are stored.
+    """
+
+    def __init__(self, prefix: str, config: OAVConfigBeamCentre, name: str = ""):
+        super().__init__(prefix, config, name)
+
+        with self.add_children_as_readables():
+            self.beam_centre_i = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.X],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
+            )
+            self.beam_centre_j = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.Y],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
+            )
+        # Set name so that new child signals get correct name
+        self.set_name(self.name)
+
+    def _get_beam_position(self, zoom_level: str, size: int, coord: int) -> int:
+        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
+        zoom level. """
+        _zoom = self._read_current_zoom(zoom_level)
+        value = self.parameters[_zoom].crosshair[coord]
+        return int(value * size / DEFAULT_OAV_WINDOW[coord])
+
+
+class OAVBeamCentrePV(OAV):
+    """OAV device that reads its beam centre values from PVs."""
+
+    def __init__(
+        self, prefix: str, config: OAVConfig, name: str = "", overlay_channel: int = 1
+    ):
+        with self.add_children_as_readables():
+            self.beam_centre_i = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterX"
+            )
+            self.beam_centre_j = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterY"
+            )
+        super().__init__(prefix, config, name)

dodal/devices/oav/oav_parameters.py

@@ -1,8 +1,9 @@
 import json
 import xml.etree.ElementTree as et
+from abc import abstractmethod
 from collections import ChainMap
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 from xml.etree.ElementTree import Element
 
 # GDA currently assumes this aspect ratio for the OAV window size.
@@ -107,22 +108,19 @@ class OAVParameters:
 @dataclass
 class ZoomParams:
     microns_per_pixel: tuple[float, float]
+
+
+@dataclass
+class ZoomParamsCrosshair(ZoomParams):
     crosshair: tuple[int, int]
 
 
-class OAVConfig:
-    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
-    with information about microns per pixels and crosshairs.
-    """
+ParamType = TypeVar("ParamType", bound="ZoomParams")
 
-    def __init__(self, zoom_params_file: str, display_config_file: str):
-        self.zoom_params = self._get_zoom_params(zoom_params_file)
-        self.display_config = self._get_display_config(display_config_file)
 
-    def _get_display_config(self, display_config_file: str):
-        with open(display_config_file) as f:
-            file_lines = f.readlines()
-        return file_lines
+class OAVConfigBase(Generic[ParamType]):
+    def __init__(self, zoom_params_file: str):
+        self.zoom_params = self._get_zoom_params(zoom_params_file)
 
     def _get_zoom_params(self, zoom_params_file: str):
         tree = et.parse(zoom_params_file)
@@ -138,6 +136,39 @@ class OAVConfig:
             um_per_pix[zoom] = (um_pix_x, um_pix_y)
         return um_per_pix
 
+    @abstractmethod
+    def get_parameters(self) -> dict[str, ParamType]: ...
+
+
+class OAVConfig(OAVConfigBase[ZoomParams]):
+    def get_parameters(self) -> dict[str, ZoomParams]:
+        config = {}
+        um_xy = self._read_zoom_params()
+        for zoom_key in list(um_xy.keys()):
+            config[zoom_key] = ZoomParams(
+                microns_per_pixel=um_xy[zoom_key],
+            )
+        return config
+
+
+class OAVConfigBeamCentre(OAVConfigBase[ZoomParamsCrosshair]):
+    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
+    with information about microns per pixels and crosshairs.
+    """
+
+    def __init__(
+        self,
+        zoom_params_file: str,
+        display_config_file: str,
+    ):
+        self.display_config = self._get_display_config(display_config_file)
+        super().__init__(zoom_params_file)
+
+    def _get_display_config(self, display_config_file: str):
+        with open(display_config_file) as f:
+            file_lines = f.readlines()
+        return file_lines
+
     def _read_display_config(self) -> dict:
         crosshairs = {}
         for i in range(len(self.display_config)):
@@ -148,13 +179,12 @@ class OAVConfig:
                 crosshairs[zoom] = (x, y)
         return crosshairs
 
-    def get_parameters(self) -> dict[str, ZoomParams]:
+    def get_parameters(self) -> dict[str, ZoomParamsCrosshair]:
         config = {}
         um_xy = self._read_zoom_params()
         bc_xy = self._read_display_config()
         for zoom_key in list(bc_xy.keys()):
-            config[zoom_key] = ZoomParams(
-                microns_per_pixel=um_xy[zoom_key],
-                crosshair=bc_xy[zoom_key],
+            config[zoom_key] = ZoomParamsCrosshair(
+                microns_per_pixel=um_xy[zoom_key], crosshair=bc_xy[zoom_key]
             )
         return config

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -1,7 +1,7 @@
 import asyncio
 from collections.abc import Awaitable, Callable
 from datetime import timedelta
-from enum import Enum
+from enum import IntEnum
 from uuid import uuid4
 
 from aiohttp import ClientResponse, ClientSession
@@ -29,7 +29,7 @@ async def get_next_jpeg(response: ClientResponse) -> bytes:
             return line + await response.content.readuntil(JPEG_STOP_BYTE)
 
 
-class Source(Enum):
+class Source(IntEnum):
     FULL_SCREEN = 0
     ROI = 1
 

dodal/devices/oav/utils.py

@@ -7,7 +7,7 @@ from bluesky.utils import Msg
 
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
-    camera_coordinates_to_xyz,
+    camera_coordinates_to_xyz_mm,
 )
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -90,7 +90,7 @@ def calculate_x_y_z_of_pixel(
     """Get the x, y, z position of a pixel in mm"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
-    return current_x_y_z + camera_coordinates_to_xyz(
+    return current_x_y_z + camera_coordinates_to_xyz_mm(
         beam_distance_px[0],
         beam_distance_px[1],
         current_omega,

dodal/devices/p99/andor2_point.py

@@ -0,0 +1,41 @@
+from ophyd_async.core import (
+    StandardReadableFormat,
+)
+from ophyd_async.epics.adandor import Andor2DriverIO
+from ophyd_async.epics.adcore import NDPluginBaseIO, SingleTriggerDetector
+from ophyd_async.epics.core import epics_signal_r
+
+
+class Andor2Point(SingleTriggerDetector):
+    """Using the andor2 as if it is a massive point detector, read the read uncached
+    value after a picture is taken."""
+
+    def __init__(
+        self,
+        prefix: str,
+        drv_suffix: str,
+        read_uncached: dict[str, str],
+        name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        prefix: str,
+           Beamline camera pv
+        drv_suffix : str,
+            Camera pv suffix
+        read_uncached: dict[str,str]
+            A dictionary contains the name and the pv suffix for the statistic plugin.
+        name: str:
+            Name of the device.
+        plugins:: Optional[dict[str, NDPluginBaseIO] | None
+            Dictionary containing plugin that are forward to the base class.
+        """
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            for k, v in read_uncached.items():
+                setattr(self, k, epics_signal_r(float, prefix + v))
+
+        super().__init__(
+            drv=Andor2DriverIO(prefix + drv_suffix), name=name, plugins=plugins
+        )

dodal/devices/positioner.py

@@ -0,0 +1,49 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.epics.core import (
+    epics_signal_rw,
+)
+from ophyd_async.epics.motor import Motor
+
+T = TypeVar("T", bound=StrictEnum)
+
+
+class Positioner1D(StandardReadable, Movable[T]):
+    """1D stage with a enum table to select positions.
+
+    Use this when writing a device with an EPICS positioner on a single axis.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        datatype: type[StrictEnum],
+        positioner_pv_suffix: str = ":MP:SELECT",
+        name: str = "",
+    ) -> None:
+        self._stage_motion = Motor(prefix=prefix)
+        with self.add_children_as_readables():
+            self.stage_position = epics_signal_rw(
+                datatype,
+                read_pv=prefix + positioner_pv_suffix,
+            )
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: T) -> None:
+        await self.stage_position.set(value=value)
+
+
+def create_positioner(
+    datatype: type[T],
+    prefix,
+    positioner_pv_suffix: str = ":MP:SELECT",
+    name: str = "",
+) -> Positioner1D[T]:
+    return Positioner1D[datatype](prefix, datatype, positioner_pv_suffix, name)

dodal/devices/robot.py

@@ -11,7 +11,12 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_x,
+)
 
 from dodal.log import LOGGER
 
@@ -88,6 +93,20 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.controller_error = ErrorStatus(prefix + "CNTL")
 
         self.reset = epics_signal_x(prefix + "RESET.PROC")
+        self.stop = epics_signal_x(prefix + "ABORT.PROC")
+        self.init = epics_signal_x(prefix + "INIT.PROC")
+        self.soak = epics_signal_x(prefix + "SOAK.PROC")
+        self.home = epics_signal_x(prefix + "GOHM.PROC")
+        self.unload = epics_signal_x(prefix + "UNLD.PROC")
+        self.dry = epics_signal_x(prefix + "DRY.PROC")
+        self.open = epics_signal_x(prefix + "COLO.PROC")
+        self.close = epics_signal_x(prefix + "COLC.PROC")
+        self.cryomode_rbv = epics_signal_r(float, prefix + "CRYO_MODE_RBV")
+        self.cryomode = epics_signal_rw(str, prefix + "CRYO_MODE_CTRL")
+        self.gripper_temp = epics_signal_r(float, prefix + "GRIPPER_TEMP")
+        self.dewar_lid_temperature = epics_signal_rw(
+            float, prefix + "DW_1_TEMP", prefix + "DW_1_SET_POINT"
+        )
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):

dodal/devices/smargon.py

@@ -1,14 +1,23 @@
+import asyncio
 from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import cast
+from typing import TypedDict, cast
 
 from bluesky import plan_stubs as bps
+from bluesky.protocols import Movable
 from bluesky.utils import Msg
-from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
-from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    StandardReadable,
+    StrictEnum,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
+from typing_extensions import NotRequired
 
 from dodal.devices.util.epics_util import SetWhenEnabled
 
@@ -91,7 +100,23 @@ class XYZLimits:
         )
 
 
-class Smargon(StandardReadable):
+class DeferMoves(StrictEnum):
+    ON = "Defer On"
+    OFF = "Defer Off"
+
+
+class CombinedMove(TypedDict):
+    """A move on multiple axes at once using a deferred move"""
+
+    x: NotRequired[float | None]
+    y: NotRequired[float | None]
+    z: NotRequired[float | None]
+    omega: NotRequired[float | None]
+    phi: NotRequired[float | None]
+    chi: NotRequired[float | None]
+
+
+class Smargon(StandardReadable, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -116,6 +141,8 @@ class Smargon(StandardReadable):
             self.stub_offsets = StubOffsets(prefix=prefix)
             self.disabled = epics_signal_r(int, prefix + "DISABLED")
 
+        self.defer_move = epics_signal_rw(DeferMoves, prefix + "CS1:DeferMoves")
+
         super().__init__(name)
 
     def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
@@ -135,3 +162,15 @@ class Smargon(StandardReadable):
             max_value = yield from bps.rd(pv.high_limit_travel)
             limits[name] = AxisLimit(min_value, max_value)
         return XYZLimits(**limits)
+
+    @AsyncStatus.wrap
+    async def set(self, value: CombinedMove):
+        await self.defer_move.set(DeferMoves.ON)
+        try:
+            tasks = []
+            for k, v in value.items():
+                if v is not None:
+                    tasks.append(getattr(self, k).set(v))
+            await asyncio.gather(*tasks)
+        finally:
+            await self.defer_move.set(DeferMoves.OFF)

dodal/devices/tetramm.py

@@ -131,11 +131,14 @@ class TetrammController(DetectorController):
         )
 
     async def arm(self):
-        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
+        self._arm_status = await set_and_wait_for_value(
+            self._drv.acquire, True, wait_for_set_completion=False
+        )
 
     async def wait_for_idle(self):
-        if self._arm_status:
+        if self._arm_status and not self._arm_status.done:
             await self._arm_status
+        self._arm_status = None
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {

dodal/devices/util/adjuster_plans.py

@@ -20,6 +20,6 @@ def lookup_table_adjuster(
     def adjust(group=None) -> Generator[Msg, None, None]:
         setpoint = lookup_table(input)
         LOGGER.info(f"lookup_table_adjuster setting {output_device.name} to {setpoint}")
-        yield from bps.abs_set(output_device, setpoint, group=group)  # type: ignore # See: https://github.com/DiamondLightSource/dodal/issues/827
+        yield from bps.abs_set(output_device, setpoint, group=group)
 
     return adjust

dodal/devices/zebra/zebra.py

@@ -68,6 +68,14 @@ class RotationDirection(StrictEnum):
     def multiplier(self):
         return 1 if self == RotationDirection.POSITIVE else -1
 
+    @property
+    def opposite(self) -> RotationDirection:
+        return (
+            RotationDirection.POSITIVE
+            if self == RotationDirection.NEGATIVE
+            else RotationDirection.NEGATIVE
+        )
+
 
 class ArmDemand(Enum):
     ARM = 1

dodal/devices/zebra/zebra_constants_mapping.py

@@ -89,7 +89,7 @@ class ZebraMapping(ZebraMappingValidations):
     # Which of the Zebra's four AND gates is used to control the automatic shutter, if it's being used.
     # After defining, the correct GateControl device can be accessed with, eg,
     # zebra.logic_gates.and_gates[zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER]. Set to -1 if not being used.
-    AND_GATE_FOR_AUTO_SHUTTER: int = Field(default=-1, ge=-1, le=4)
+    AND_GATE_FOR_AUTO_SHUTTER: int = Field(default=2, ge=-1, le=4)
 
 
 class UnmappedZebraException(Exception):

dodal/devices/zocalo/__init__.py

@@ -12,10 +12,7 @@ __all__ = [
     "XrcResult",
     "ZocaloTrigger",
     "get_full_processing_results",
-    "ZOCALO_READING_PLAN_NAME",
     "NoResultsFromZocalo",
     "NoZocaloSubscription",
     "ZocaloStartInfo",
 ]
-
-ZOCALO_READING_PLAN_NAME = "zocalo reading"

dodal/devices/zocalo/zocalo_results.py

@@ -1,7 +1,6 @@
 import asyncio
 from collections.abc import Generator, Sequence
 from enum import Enum
-from inspect import get_annotations
 from queue import Empty, Queue
 from typing import Any, TypedDict
 
@@ -47,7 +46,6 @@ class ZocaloSource(str, Enum):
 
 DEFAULT_TIMEOUT = 180
 DEFAULT_SORT_KEY = SortKeys.max_count
-ZOCALO_READING_PLAN_NAME = "zocalo reading"
 CLEAR_QUEUE_WAIT_S = 2.0
 ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
@@ -389,12 +387,12 @@ def get_full_processing_results(
     """A plan that will return the raw zocalo results, ranked in descending order according to the sort key.
     Returns empty list in the event no results found."""
     LOGGER.info("Retrieving raw zocalo processing results")
-    com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])  # type: ignore
-    max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])  # type: ignore
-    max_count = yield from bps.rd(zocalo.max_count, default_value=[])  # type: ignore
-    n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])  # type: ignore
-    total_count = yield from bps.rd(zocalo.total_count, default_value=[])  # type: ignore
-    bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])  # type: ignore
+    com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])
+    max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])
+    max_count = yield from bps.rd(zocalo.max_count, default_value=[])
+    n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])
+    total_count = yield from bps.rd(zocalo.total_count, default_value=[])
+    bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])
     return [
         _corrected_xrc_result(
             XrcResult(
@@ -410,27 +408,3 @@ def get_full_processing_results(
             com, max_voxel, max_count, n_voxels, total_count, bounding_box, strict=True
         )
     ]
-
-
-def get_processing_results_from_event(
-    device_name: str, doc: dict
-) -> Sequence[XrcResult]:
-    """
-    Decode an event document into the corresponding x-ray centring results
-
-    Args:
-    doc         A bluesky event document containing the signals read from the ZocaloResults
-    device_name The device name prefix to prepend to the document keys
-
-    Returns:
-        The list of XrcResults decoded from the event document
-    """
-    results_keys = get_annotations(XrcResult).keys()
-    results_dict = {k: doc["data"][f"{device_name}-{k}"] for k in results_keys}
-    results_values = [results_dict[k].tolist() for k in results_keys]
-
-    def create_result(*argv):
-        kwargs = dict(zip(results_keys, argv, strict=False))
-        return XrcResult(**kwargs)
-
-    return list(map(create_result, *results_values))