dls-dodal 1.52.0__py3-none-any.whl → 1.54.0__py3-none-any.whl

dodal/devices/electron_analyser/types.py

@@ -22,27 +22,36 @@ from dodal.devices.electron_analyser.vgscienta.detector import (
 
 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] | SpecsDetector[AnyLensMode]
+    VGScientaDetector[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
+    | SpecsDetector[AnyLensMode, AnyPsuMode]
 )
 ElectronAnalyserDriverImpl = (
-    VGScientaAnalyserDriverIO[AnyLensMode] | SpecsAnalyserDriverIO[AnyLensMode]
+    VGScientaAnalyserDriverIO[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
+    | SpecsAnalyserDriverIO[AnyLensMode, AnyPsuMode]
 )
 
 # Short hand the type so less verbose
-AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode]
+AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode, AnyPassEnergy]
 
 # Generic electron analyser types that supports full typing with the abstract classes.
 GenericElectronAnalyserDetector = ElectronAnalyserDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
-    AbstractBaseSequence[AbstractBaseRegion, AnyLensMode],
+    AbstractAnalyserDriverIO[
+        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+    ],
+    AbstractBaseSequence[AbstractBaseRegion],
     AbstractBaseRegion,
 ]
 
 GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
+    AbstractAnalyserDriverIO[
+        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+    ],
     AbstractBaseRegion,
 ]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -3,7 +3,11 @@ from typing import Generic
 
 from ophyd_async.core import SignalR
 
-from dodal.devices.electron_analyser.abstract.base_region import TLensMode
+from dodal.devices.electron_analyser.abstract.types import (
+    TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
+)
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -18,20 +22,26 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 
 class VGScientaDetector(
     ElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO[TLensMode],
-        VGScientaSequence[TLensMode],
-        VGScientaRegion[TLensMode],
+        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
     ],
-    Generic[TLensMode],
+    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_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ):
-        driver = VGScientaAnalyserDriverIO[TLensMode](
-            prefix, lens_mode_type, energy_sources
+        driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_sources
+        )
+        super().__init__(
+            VGScientaSequence[lens_mode_type, psu_mode_type, pass_energy_type],
+            driver,
+            name,
         )
-        super().__init__(VGScientaSequence[lens_mode_type], driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -15,54 +15,96 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.base_region import TLensMode
+from dodal.devices.electron_analyser.abstract.types import (
+    TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
+)
 from dodal.devices.electron_analyser.util import to_kinetic_energy
-from dodal.devices.electron_analyser.vgscienta.enums import AcquisitionMode
-from dodal.devices.electron_analyser.vgscienta.region import (
+from dodal.devices.electron_analyser.vgscienta.enums import (
+    AcquisitionMode,
     DetectorMode,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
     VGScientaRegion,
 )
 
 
 class VGScientaAnalyserDriverIO(
-    AbstractAnalyserDriverIO[VGScientaRegion, AcquisitionMode, TLensMode],
-    Generic[TLensMode],
+    AbstractAnalyserDriverIO[
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
+        AcquisitionMode,
+        TLensMode,
+        TPsuMode,
+        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_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
-            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
-            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
-            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
-            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
-            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
             self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
 
-        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
+            self.region_min_x = epics_signal_rw(int, prefix + "MinX")
+            self.region_size_x = epics_signal_rw(int, prefix + "SizeX")
+            self.sensor_max_size_x = epics_signal_rw(int, prefix + "MaxSizeX")
+
+            self.region_min_y = epics_signal_rw(int, prefix + "MinY")
+            self.region_size_y = epics_signal_rw(int, prefix + "SizeY")
+            self.sensor_max_size_y = epics_signal_rw(int, prefix + "MaxSizeY")
+
+        super().__init__(
+            prefix,
+            AcquisitionMode,
+            lens_mode_type,
+            psu_mode_type,
+            pass_energy_type,
+            energy_sources,
+            name,
+        )
 
     @AsyncStatus.wrap
-    async def set(self, region: VGScientaRegion[TLensMode]):
-        await super().set(region)
+    async def set(self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
 
-        excitation_energy = await self.excitation_energy.get_value()
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
         centre_energy = to_kinetic_energy(
-            region.fix_energy, region.energy_mode, excitation_energy
+            region.centre_energy, region.energy_mode, excitation_energy
+        )
+        high_energy = to_kinetic_energy(
+            region.high_energy, region.energy_mode, excitation_energy
         )
         await asyncio.gather(
+            self.region_name.set(region.name),
+            self.energy_mode.set(region.energy_mode),
+            self.low_energy.set(low_energy),
             self.centre_energy.set(centre_energy),
+            self.high_energy.set(high_energy),
+            self.slices.set(region.slices),
+            self.lens_mode.set(region.lens_mode),
+            self.pass_energy.set(region.pass_energy),
+            self.iterations.set(region.iterations),
+            self.acquisition_mode.set(region.acquisition_mode),
+            self.excitation_energy.set(excitation_energy),
+            self.excitation_energy_source.set(source.name),
             self.energy_step.set(region.energy_step),
-            self.first_x_channel.set(region.first_x_channel),
-            self.first_y_channel.set(region.first_y_channel),
-            self.x_channel_size.set(region.x_channel_size()),
-            self.y_channel_size.set(region.y_channel_size()),
-            self.detector_mode.set(region.detector_mode),
             self.image_mode.set(ADImageMode.SINGLE),
+            self.detector_mode.set(region.detector_mode),
+            self.region_min_x.set(region.min_x),
+            self.region_size_x.set(region.size_x),
+            self.region_min_y.set(region.min_y),
+            self.region_size_y.set(region.size_y),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
@@ -70,7 +112,3 @@ class VGScientaAnalyserDriverIO(
 
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         return epics_signal_r(Array1D[np.float64], prefix + "Y_SCALE_RBV")
-
-    @property
-    def pass_energy_type(self) -> type:
-        return str

dodal/devices/electron_analyser/vgscienta/region.py

@@ -1,13 +1,17 @@
 import uuid
 from typing import Generic
 
-from pydantic import Field
+from pydantic import Field, field_validator
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,
+)
+from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
 )
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
@@ -17,33 +21,43 @@ from dodal.devices.electron_analyser.vgscienta.enums import (
 
 
 class VGScientaRegion(
-    AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]
+    AbstractBaseRegion[AcquisitionMode, TLensMode, TPassEnergyEnum],
+    Generic[TLensMode, TPassEnergyEnum],
 ):
     # Override defaults of base region class
     lens_mode: TLensMode
-    pass_energy: int = 5
+    pass_energy: TPassEnergyEnum
     acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
     high_energy: float = 10.0
     step_time: float = 1.0
     energy_step: float = Field(default=200.0)
+    centre_energy: float = Field(alias="fix_energy", default=9)
     # Specific to this class
     id: str = Field(default=str(uuid.uuid4()), alias="region_id")
-    fix_energy: float = 9.0
     total_steps: float = 13.0
     total_time: float = 13.0
-    first_x_channel: int = 1
-    last_x_channel: int = 1000
-    first_y_channel: int = 101
-    last_y_channel: int = 800
+    min_x: int = Field(alias="first_x_channel", default=1)
+    sensor_max_size_x: int = Field(alias="last_x_channel", default=1000)
+    min_y: int = Field(alias="first_y_channel", default=101)
+    sensor_max_size_y: int = Field(alias="last_y_channel", default=800)
     detector_mode: DetectorMode = DetectorMode.ADC
     status: Status = Status.READY
 
-    def x_channel_size(self) -> int:
-        return self.last_x_channel - self.first_x_channel + 1
+    @property
+    def size_x(self) -> int:
+        return self.sensor_max_size_x - self.min_x + 1
+
+    @property
+    def size_y(self) -> int:
+        return self.sensor_max_size_y - self.min_y + 1
 
-    def y_channel_size(self) -> int:
-        return self.last_y_channel - self.first_y_channel + 1
+    @field_validator("pass_energy", mode="before")
+    @classmethod
+    def validate_pass_energy(cls, val):
+        # This is needed because if the value is a number, it can't be casted to the
+        # enum correctly.
+        return str(val)
 
 
 class VGScientaExcitationEnergySource(JavaToPythonModel):
@@ -53,16 +67,19 @@ class VGScientaExcitationEnergySource(JavaToPythonModel):
 
 
 class VGScientaSequence(
-    AbstractBaseSequence[VGScientaRegion, TLensMode], Generic[TLensMode]
+    AbstractBaseSequence[VGScientaRegion[TLensMode, TPassEnergyEnum]],
+    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
 ):
-    element_set: str = Field(default="Unknown")
+    psu_mode: TPsuMode = Field(alias="element_set")
     excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
         default_factory=lambda: []
     )
-    regions: list[VGScientaRegion[TLensMode]] = Field(default_factory=lambda: [])
+    regions: list[VGScientaRegion[TLensMode, TPassEnergyEnum]] = Field(
+        default_factory=lambda: []
+    )
 
     def get_excitation_energy_source_by_region(
-        self, region: VGScientaRegion[TLensMode]
+        self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]
     ) -> VGScientaExcitationEnergySource:
         value = next(
             (

dodal/devices/i05/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.i05.enums import Grating
+
+__all__ = ["Grating"]

dodal/devices/i05/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class Grating(StrictEnum):
+    PT_400 = "400 lines/mm"
+    C_1600 = "C 1600 lines/mm"
+    RH_1600 = "Rh 1600 lines/mm"
+    PT_800 = "B 800 lines/mm"

dodal/devices/i09/__init__.py

@@ -1,4 +1,4 @@
 from dodal.devices.i09.dcm import DCM
-from dodal.devices.i09.enums import Grating, LensMode
+from dodal.devices.i09.enums import Grating, LensMode, PassEnergy, PsuMode
 
-__all__ = ["DCM", "Grating", "LensMode"]
+__all__ = ["DCM", "Grating", "LensMode", "PsuMode", "PassEnergy"]

dodal/devices/i09/enums.py

@@ -13,3 +13,19 @@ class LensMode(StrictEnum):
     ANGULAR60 = "Angular60"
     ANGULAR56 = "Angular56"
     ANGULAR45VUV = "Angular45VUV"
+
+
+class PsuMode(StrictEnum):
+    HIGH = "High"
+    LOW = "Low"
+
+
+class PassEnergy(StrictEnum):
+    E5 = 5
+    E10 = 10
+    E20 = 20
+    E50 = 50
+    E70 = 70
+    E100 = 100
+    E200 = 200
+    E500 = 500

dodal/devices/i09_1/__init__.py

@@ -1,3 +1,3 @@
-from .enums import LensMode
+from .enums import LensMode, PsuMode
 
-__all__ = ["LensMode"]
+__all__ = ["LensMode", "PsuMode"]

dodal/devices/i09_1/enums.py

@@ -16,4 +16,17 @@ class LensMode(SupersetEnum):
     LOW_MAGNIFICATION = "LowMagnification"
     HIGH_MAGNIFICATION2 = "HighMagnification2"
     RAMP_MODE = "RampMode"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
+    NOT_CONNECTED = "Not connected"
+
+
+class PsuMode(SupersetEnum):
+    V3500 = "3.5kV"
+    V1500 = "1.5kV"
+    V400 = "400V"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
     NOT_CONNECTED = "Not connected"

dodal/devices/i13_1/merlin_controller.py

@@ -12,8 +12,8 @@ from ophyd_async.epics.adcore import (
     ADBaseIO,
     ADImageMode,
     ADState,
-    stop_busy_record,
 )
+from ophyd_async.epics.core import stop_busy_record
 
 
 class MerlinController(ADBaseController):

dodal/devices/i19/beamstop.py

@@ -6,7 +6,7 @@ from dodal.devices.motors import XYZStage
 
 class HomeGroup(StrictEnum):
     NONE = "none"
-    ALL = "All"
+    ALL = "ALL"
     X = "X"
     Y = "Y"
     Z = "Z"
@@ -23,4 +23,4 @@ class BeamStop(XYZStage):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.homing = HomingControl(f"{prefix}HM", name)
 
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/i24/aperture.py

@@ -22,4 +22,4 @@ class Aperture(XYStage):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.position = epics_signal_rw(AperturePositions, prefix + "MP:SELECT")
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -110,11 +110,11 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         pickled numpy array of pixel values but raw byes are more space efficient. There
         may be better ways of doing this, see https://github.com/DiamondLightSource/mx-bluesky/issues/592"""
         jpeg_bytes = await get_next_jpeg(response)
-        self.uuid_setter(redis_uuid)
         sample_id = await self.sample_id.get_value()
         redis_key = f"murko:{sample_id}:raw"
         await self.redis_client.hset(redis_key, redis_uuid, jpeg_bytes)  # type: ignore
         await self.redis_client.expire(redis_key, timedelta(days=self.DATA_EXPIRY_DAYS))
+        self.uuid_setter(redis_uuid)
 
     async def _open_connection_and_do_function(
         self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -1,4 +1,3 @@
-import asyncio
 import time
 
 import numpy as np
@@ -160,7 +159,7 @@ class PinTipDetection(StandardReadable):
                     )
                 else:
                     break
-        except asyncio.exceptions.TimeoutError:
+        except TimeoutError:
             LOGGER.error(
                 f"No tip found in {await self.validity_timeout.get_value()} seconds."
             )

dodal/devices/p60/__init__.py

@@ -1,4 +1,10 @@
-from .enums import LensMode
+from .enums import LensMode, PassEnergy, PsuMode
 from .lab_xray_source import LabXraySource, LabXraySourceReadable
 
-__all__ = ["LensMode", "LabXraySource", "LabXraySourceReadable"]
+__all__ = [
+    "LensMode",
+    "PsuMode",
+    "PassEnergy",
+    "LabXraySource",
+    "LabXraySourceReadable",
+]

dodal/devices/p60/enums.py

@@ -8,3 +8,19 @@ class LensMode(StrictEnum):
     ANGULAR30 = "Angular30"
     ANGULAR30_SMALLSPOT = "Angular30_SmallSpot"
     ANGULAR14_SMALLSPOT = "Angular14_SmallSpot"
+
+
+class PsuMode(StrictEnum):
+    HIGH = "High Pass (XPS)"
+    LOW = "Low Pass (UPS)"
+
+
+class PassEnergy(StrictEnum):
+    E1 = 1
+    E2 = 2
+    E5 = 5
+    E10 = 10
+    E20 = 20
+    E50 = 50
+    E100 = 100
+    E200 = 200

dodal/devices/robot.py

@@ -21,6 +21,9 @@ from ophyd_async.epics.core import (
 
 from dodal.log import LOGGER
 
+WAIT_FOR_OLD_PIN_MSG = "Waiting on old pin unloaded"
+WAIT_FOR_NEW_PIN_MSG = "Waiting on new pin loaded"
+
 
 class RobotLoadFailed(Exception):
     error_code: int
@@ -144,6 +147,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
             # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
             for task in tasks:
                 task.cancel()
+
             raise
 
     async def _load_pin_and_puck(self, sample_location: SampleLocation):
@@ -164,9 +168,9 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         )
         await self.load.trigger()
         if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
-            LOGGER.info("Waiting on old pin unloaded")
+            LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
             await wait_for_value(self.gonio_pin_sensor, PinMounted.NO_PIN_MOUNTED, None)
-        LOGGER.info("Waiting on new pin loaded")
+        LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
 
         await self.pin_mounted_or_no_pin_found()
 
@@ -178,7 +182,6 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
                 timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
         except TimeoutError as e:
-            # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)
             raise RobotLoadFailed(0, "Robot timed out") from e

dodal/devices/tetramm.py

@@ -22,9 +22,8 @@ from ophyd_async.epics.adcore import (
     NDArrayBaseIO,
     NDFileHDFIO,
     NDPluginBaseIO,
-    stop_busy_record,
 )
-from ophyd_async.epics.core import PvSuffix
+from ophyd_async.epics.core import PvSuffix, stop_busy_record
 
 
 class TetrammRange(StrictEnum):

dodal/utils.py

@@ -426,16 +426,9 @@ def is_v2_device_type(obj: type[Any]) -> bool:
             # This is all very badly documented and possibly prone to change in future versions of Python
             non_parameterized_class = obj.__origin__
         if non_parameterized_class:
-            try:
-                return non_parameterized_class and issubclass(
-                    non_parameterized_class, OphydV2Device
-                )
-            except TypeError:
-                # Python 3.10 will return inspect.isclass(t) == True but then
-                # raise TypeError: issubclass() arg 1 must be a class
-                # when inspecting device_factory decorator function itself
-                # Later versions of Python seem not to be affected
-                pass
+            return non_parameterized_class and issubclass(
+                non_parameterized_class, OphydV2Device
+            )
 
     return False