dls-dodal 1.67.0__py3-none-any.whl → 1.69.0__py3-none-any.whl

dodal/devices/zebra/zebra.py

@@ -7,11 +7,15 @@ from functools import partialmethod
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
+    DeviceMock,
     DeviceVector,
     SignalRW,
     StandardReadable,
     StrictEnum,
+    callback_on_mock_put,
+    default_mock_class,
     observe_value,
+    set_mock_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
@@ -88,6 +92,17 @@ class SoftInState(StrictEnum):
     NO = "No"
 
 
+class InstantArmMock(DeviceMock["ArmingDevice"]):
+    async def connect(self, device: ArmingDevice) -> None:
+        callback_on_mock_put(
+            device.arm_set, lambda *_, **__: set_mock_value(device.armed, 1)
+        )
+        callback_on_mock_put(
+            device.disarm_set, lambda *_, **__: set_mock_value(device.armed, 0)
+        )
+
+
+@default_mock_class(InstantArmMock)
 class ArmingDevice(StandardReadable, Movable[ArmDemand]):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""

dodal/devices/zebra/zebra_constants_mapping.py

@@ -49,6 +49,7 @@ class ZebraTTLOutputs(ZebraMappingValidations):
     TTL_SHUTTER: int = Field(default=-1, ge=-1, le=4)
     TTL_XSPRESS3: int = Field(default=-1, ge=-1, le=4)
     TTL_PANDA: int = Field(default=-1, ge=-1, le=4)
+    TTL_JUNGFRAU: int = Field(default=-1, ge=-1, le=4)
 
 
 class ZebraSources(ZebraMappingValidations):

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -76,7 +76,6 @@ def set_cam_pvs(
     yield from bps.abs_set(
         eiger.drv.detector.frame_time, detector_params.exposure_time_s, group=group
     )
-    yield from bps.abs_set(eiger.drv.detector.nexpi, 1, group=group)
 
     if wait:
         yield from bps.wait(group)

dodal/testing/electron_analyser/device_factory.py

@@ -1,16 +1,16 @@
 from typing import Any, get_args, get_origin
 
-from dodal.devices.electron_analyser.abstract import (
+from dodal.devices.electron_analyser.base.base_detector import TElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_driver_io import (
     TAbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.detector import TElectronAnalyserDetector
 from dodal.devices.electron_analyser.vgscienta import (
     VGScientaAnalyserDriverIO,
     VGScientaDetector,
 )
 
 
-async def create_driver(
+def create_driver(
     driver_class: type[TAbstractAnalyserDriverIO],
     **kwargs: Any,
 ) -> TAbstractAnalyserDriverIO:
@@ -34,7 +34,7 @@ async def create_driver(
     return driver_class(**(parameters | kwargs))
 
 
-async def create_detector(
+def create_detector(
     detector_class: type[TElectronAnalyserDetector],
     **kwargs: Any,
 ) -> TElectronAnalyserDetector:

dodal/testing/fixtures/devices/apple2.py

@@ -7,7 +7,7 @@ from ophyd_async.core import (
     set_mock_value,
 )
 
-from dodal.devices.insertion_device.apple2_undulator import (
+from dodal.devices.insertion_device import (
     EnabledDisabledUpper,
     UndulatorGap,
     UndulatorGateStatus,

dodal/testing/fixtures/run_engine.py

@@ -3,6 +3,7 @@ Allow external repos to reuse these fixtures so defined in single place.
 """
 
 import asyncio
+import copy
 import os
 import threading
 import time
@@ -34,10 +35,13 @@ async def _ensure_running_bluesky_event_loop(_global_run_engine):
 
 @pytest.fixture()
 async def run_engine(_global_run_engine: RunEngine) -> AsyncGenerator[RunEngine, None]:
+    initial_md = copy.deepcopy(_global_run_engine.md)
     try:
         yield _global_run_engine
     finally:
+        # Clear subscriptions, cache, and reset metadata
         _global_run_engine.reset()
+        _global_run_engine.md = initial_md
 
 
 @pytest_asyncio.fixture(scope="session", loop_scope="session")

dodal/devices/electron_analyser/abstract/__init__.py

@@ -1,25 +0,0 @@
-from .base_detector import (
-    BaseElectronAnalyserDetector,
-)
-from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO
-from .base_region import (
-    AbstractBaseRegion,
-    AbstractBaseSequence,
-    TAbstractBaseRegion,
-    TAbstractBaseSequence,
-    TAcquisitionMode,
-    TLensMode,
-)
-
-__all__ = [
-    "AbstractBaseRegion",
-    "AbstractBaseSequence",
-    "TAbstractBaseRegion",
-    "TAbstractBaseSequence",
-    "TAcquisitionMode",
-    "TLensMode",
-    "AbstractAnalyserDriverIO",
-    "BaseElectronAnalyserDetector",
-    "AbstractAnalyserDriverIO",
-    "TAbstractAnalyserDriverIO",
-]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,63 +0,0 @@
-from typing import Generic
-
-from bluesky.protocols import Reading, Triggerable
-from event_model import DataKey
-from ophyd_async.core import (
-    AsyncConfigurable,
-    AsyncReadable,
-    AsyncStatus,
-    Device,
-)
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
-    TAbstractAnalyserDriverIO,
-)
-
-
-class BaseElectronAnalyserDetector(
-    Device,
-    Triggerable,
-    AsyncReadable,
-    AsyncConfigurable,
-    Generic[TAbstractAnalyserDriverIO],
-):
-    """
-    Detector for data acquisition of electron analyser. Can only acquire using settings
-    already configured for the device.
-
-    If possible, this should be changed to inherit from a StandardDetector. Currently,
-    StandardDetector forces you to use a file writer which doesn't apply here.
-    See issue https://github.com/bluesky/ophyd-async/issues/888
-    """
-
-    def __init__(
-        self,
-        controller: ADBaseController[TAbstractAnalyserDriverIO],
-        name: str = "",
-    ):
-        self._controller = controller
-        super().__init__(name)
-
-    @AsyncStatus.wrap
-    async def trigger(self) -> None:
-        await self._controller.arm()
-        await self._controller.wait_for_idle()
-
-    async def read(self) -> dict[str, Reading]:
-        return await self._controller.driver.read()
-
-    async def describe(self) -> dict[str, DataKey]:
-        data = await self._controller.driver.describe()
-        # Correct the shape for image
-        prefix = self._controller.driver.name + "-"
-        energy_size = len(await self._controller.driver.energy_axis.get_value())
-        angle_size = len(await self._controller.driver.angle_axis.get_value())
-        data[prefix + "image"]["shape"] = [angle_size, energy_size]
-        return data
-
-    async def read_configuration(self) -> dict[str, Reading]:
-        return await self._controller.driver.read_configuration()
-
-    async def describe_configuration(self) -> dict[str, DataKey]:
-        return await self._controller.driver.describe_configuration()

dodal/devices/electron_analyser/abstract/types.py

@@ -1,12 +0,0 @@
-from typing import TypeVar
-
-from ophyd_async.core import StrictEnum, SupersetEnum
-
-TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
-# Allow SupersetEnum. Specs analysers can connect to Lens and Psu mode separately to the
-# analyser which leaves the enum to either be "Not connected" OR the available enums
-# when connected.
-TLensMode = TypeVar("TLensMode", bound=SupersetEnum | StrictEnum)
-TPsuMode = TypeVar("TPsuMode", bound=SupersetEnum | StrictEnum)
-TPassEnergy = TypeVar("TPassEnergy", bound=StrictEnum | float)
-TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)

dodal/devices/electron_analyser/detector.py

@@ -1,143 +0,0 @@
-from typing import Generic, TypeVar
-
-from bluesky.protocols import Stageable
-from ophyd_async.core import AsyncStatus
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.common.data_util import load_json_file_to_class
-from dodal.devices.controllers import ConstantDeadTimeController
-from dodal.devices.electron_analyser.abstract.base_detector import (
-    BaseElectronAnalyserDetector,
-)
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
-    TAbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.abstract.base_region import (
-    TAbstractBaseRegion,
-    TAbstractBaseSequence,
-)
-
-
-class ElectronAnalyserRegionDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
-):
-    """
-    Extends electron analyser detector to configure specific region settings before data
-    acquisition. It is designed to only exist inside a plan.
-    """
-
-    def __init__(
-        self,
-        controller: ADBaseController[TAbstractAnalyserDriverIO],
-        region: TAbstractBaseRegion,
-        name: str = "",
-    ):
-        self.region = region
-        super().__init__(controller, name)
-
-    @AsyncStatus.wrap
-    async def trigger(self) -> None:
-        # Configure region parameters on the driver first before data collection.
-        await self._controller.driver.set(self.region)
-        await super().trigger()
-
-
-TElectronAnalyserRegionDetector = TypeVar(
-    "TElectronAnalyserRegionDetector",
-    bound=ElectronAnalyserRegionDetector,
-)
-
-
-class ElectronAnalyserDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Stageable,
-    Generic[
-        TAbstractAnalyserDriverIO,
-        TAbstractBaseSequence,
-        TAbstractBaseRegion,
-    ],
-):
-    """
-    Electron analyser detector with the additional functionality to load a sequence file
-    and create a list of temporary ElectronAnalyserRegionDetector objects. These will
-    setup configured region settings before data acquisition.
-    """
-
-    def __init__(
-        self,
-        sequence_class: type[TAbstractBaseSequence],
-        driver: TAbstractAnalyserDriverIO,
-        name: str = "",
-    ):
-        # Save driver as direct child so participates with connect()
-        self.driver = driver
-        self._sequence_class = sequence_class
-        controller = ConstantDeadTimeController[TAbstractAnalyserDriverIO](driver, 0)
-        super().__init__(controller, name)
-
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        """
-        Prepare the detector for use by ensuring it is idle and ready.
-
-        This method asynchronously stages the detector by first disarming the controller
-        to ensure the detector is not actively acquiring data, then invokes the driver's
-        stage procedure. This ensures the detector is in a known, ready state
-        before use.
-
-        Raises:
-            Any exceptions raised by the driver's stage or controller's disarm methods.
-        """
-        await self._controller.disarm()
-        await self.driver.stage()
-
-    @AsyncStatus.wrap
-    async def unstage(self) -> None:
-        """Disarm the detector."""
-        await self._controller.disarm()
-        await self.driver.unstage()
-
-    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        """
-        Load the sequence data from a provided json file into a sequence class.
-
-        Args:
-            filename: Path to the sequence file containing the region data.
-
-        Returns:
-            Pydantic model representing the sequence file.
-        """
-        return load_json_file_to_class(self._sequence_class, filename)
-
-    def create_region_detector_list(
-        self, filename: str, enabled_only=True
-    ) -> list[
-        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
-    ]:
-        """
-        Create a list of detectors equal to the number of regions in a sequence file.
-        Each detector is responsible for setting up a specific region.
-
-        Args:
-            filename:     Path to the sequence file containing the region data.
-            enabled_only: If true, only include the region if enabled is True.
-
-        Returns:
-            List of ElectronAnalyserRegionDetector, equal to the number of regions in
-            the sequence file.
-        """
-        seq = self.load_sequence(filename)
-        regions = seq.get_enabled_regions() if enabled_only else seq.regions
-        return [
-            ElectronAnalyserRegionDetector(
-                self._controller, r, self.name + "_" + r.name
-            )
-            for r in regions
-        ]
-
-
-TElectronAnalyserDetector = TypeVar(
-    "TElectronAnalyserDetector",
-    bound=ElectronAnalyserDetector,
-)

dodal/devices/electron_analyser/specs/detector.py

@@ -1,34 +0,0 @@
-from typing import Generic
-
-from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.detector import (
-    ElectronAnalyserDetector,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
-from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
-
-
-class SpecsDetector(
-    ElectronAnalyserDetector[
-        SpecsAnalyserDriverIO[TLensMode, TPsuMode],
-        SpecsSequence[TLensMode, TPsuMode],
-        SpecsRegion[TLensMode, TPsuMode],
-    ],
-    Generic[TLensMode, TPsuMode],
-):
-    def __init__(
-        self,
-        prefix: str,
-        lens_mode_type: type[TLensMode],
-        psu_mode_type: type[TPsuMode],
-        energy_source: DualEnergySource | EnergySource,
-        name: str = "",
-    ):
-        driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
-            prefix, lens_mode_type, psu_mode_type, energy_source
-        )
-        super().__init__(SpecsSequence[lens_mode_type, psu_mode_type], driver, name)

dodal/devices/electron_analyser/types.py

@@ -1,57 +0,0 @@
-from ophyd_async.core import StrictEnum, SupersetEnum
-
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
-    AbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.abstract.base_region import (
-    AbstractBaseRegion,
-    AbstractBaseSequence,
-)
-from dodal.devices.electron_analyser.detector import (
-    ElectronAnalyserDetector,
-    ElectronAnalyserRegionDetector,
-)
-from dodal.devices.electron_analyser.specs.detector import (
-    SpecsAnalyserDriverIO,
-    SpecsDetector,
-)
-from dodal.devices.electron_analyser.vgscienta.detector import (
-    VGScientaAnalyserDriverIO,
-    VGScientaDetector,
-)
-
-AnyAcqMode = StrictEnum
-AnyLensMode = SupersetEnum | StrictEnum
-AnyPsuMode = SupersetEnum | StrictEnum
-AnyPassEnergy = StrictEnum | float
-AnyPassEnergyEnum = StrictEnum
-
-# Electron analyser types that encompasses all implementations, useful for tests and
-# plans
-ElectronAnalyserDetectorImpl = (
-    VGScientaDetector[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
-    | SpecsDetector[AnyLensMode, AnyPsuMode]
-)
-ElectronAnalyserDriverImpl = (
-    VGScientaAnalyserDriverIO[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
-    | SpecsAnalyserDriverIO[AnyLensMode, AnyPsuMode]
-)
-
-# Short hand the type so less verbose
-AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode, AnyPassEnergy]
-
-# Generic electron analyser types that supports full typing with the abstract classes.
-GenericElectronAnalyserDetector = ElectronAnalyserDetector[
-    AbstractAnalyserDriverIO[
-        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
-    ],
-    AbstractBaseSequence[AbstractBaseRegion],
-    AbstractBaseRegion,
-]
-
-GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
-    AbstractAnalyserDriverIO[
-        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
-    ],
-    AbstractBaseRegion,
-]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,48 +0,0 @@
-from typing import Generic
-
-from dodal.devices.electron_analyser.abstract.types import (
-    TLensMode,
-    TPassEnergyEnum,
-    TPsuMode,
-)
-from dodal.devices.electron_analyser.detector import (
-    ElectronAnalyserDetector,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.vgscienta.driver_io import (
-    VGScientaAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.vgscienta.region import (
-    VGScientaRegion,
-    VGScientaSequence,
-)
-
-
-class VGScientaDetector(
-    ElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
-        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
-        VGScientaRegion[TLensMode, TPassEnergyEnum],
-    ],
-    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
-):
-    def __init__(
-        self,
-        prefix: str,
-        lens_mode_type: type[TLensMode],
-        psu_mode_type: type[TPsuMode],
-        pass_energy_type: type[TPassEnergyEnum],
-        energy_source: DualEnergySource | EnergySource,
-        name: str = "",
-    ):
-        driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
-            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_source
-        )
-        super().__init__(
-            VGScientaSequence[lens_mode_type, psu_mode_type, pass_energy_type],
-            driver,
-            name,
-        )