dls-dodal 1.42.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

dodal/common/signal_utils.py

@@ -2,22 +2,26 @@ from collections.abc import Callable, Coroutine
 from typing import Any
 
 from bluesky.protocols import Reading
-from ophyd_async.core import SignalDatatypeT, SignalR, SoftSignalBackend
+from ophyd_async.core import SignalDatatypeT, SignalR, SignalRW, SoftSignalBackend
+
+SetHardwareType = Callable[[SignalDatatypeT], Coroutine[Any, Any, None]]
 
 
 class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
+        set_to_hardware_func: SetHardwareType | None = None,
         *args,
         **kwargs,
     ) -> None:
         self.get_from_hardware_func = get_from_hardware_func
+        self.set_to_hardware_func = set_to_hardware_func
         super().__init__(*args, **kwargs)
 
     async def _update_value(self):
         new_value = await self.get_from_hardware_func()
-        await self.put(new_value, True)
+        self.set_value(new_value)
 
     async def get_reading(self) -> Reading:
         await self._update_value()
@@ -27,8 +31,39 @@ class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
         await self._update_value()
         return await super().get_value()
 
+    async def put(self, value: SignalDatatypeT | None, wait: bool) -> None:
+        if self.set_to_hardware_func:
+            write_value = self.initial_value if value is None else value
+            await self.set_to_hardware_func(write_value)
+
+
+def create_rw_hardware_backed_soft_signal(
+    datatype: type[SignalDatatypeT],
+    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
+    set_to_hardware_func: SetHardwareType,
+    units: str | None = None,
+    precision: int | None = None,
+):
+    """Creates a soft signal that, when read will call the function passed into
+    `get_from_hardware_func` and return this. When set it will call `set_to_hardware_func`
+    and send something to the hardware.
+
+    This will allow you to make soft signals derived from arbitrary hardware signals.
+    However, calling subscribe on this signal does not give you a sensible value. See https://github.com/bluesky/ophyd-async/issues/525
+    for a more full solution.
+    """
+    return SignalRW(
+        backend=HardwareBackedSoftSignalBackend(
+            get_from_hardware_func,
+            set_to_hardware_func,
+            datatype,
+            units=units,
+            precision=precision,
+        )
+    )
+
 
-def create_hardware_backed_soft_signal(
+def create_r_hardware_backed_soft_signal(
     datatype: type[SignalDatatypeT],
     get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
     units: str | None = None,
@@ -44,6 +79,10 @@ def create_hardware_backed_soft_signal(
     """
     return SignalR(
         backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func, datatype, units=units, precision=precision
+            get_from_hardware_func,
+            None,
+            datatype,
+            units=units,
+            precision=precision,
         )
     )

dodal/common/visit.py

@@ -3,7 +3,8 @@ from pathlib import Path
 from typing import Literal
 
 from aiohttp import ClientSession
-from ophyd_async.core import FilenameProvider, PathInfo
+from event_model import RunStart
+from ophyd_async.core import FilenameProvider, PathInfo, PathProvider
 from pydantic import BaseModel
 
 from dodal.common.types import UpdatingPathProvider
@@ -150,3 +151,42 @@ class StaticVisitPathProvider(UpdatingPathProvider):
         return PathInfo(
             directory_path=self._root, filename=self._filename_provider(device_name)
         )
+
+
+DEFAULT_TEMPLATE = "{device_name}-{instrument}-{scan_id}"
+
+
+class StartDocumentPathProvider(PathProvider):
+    """A PathProvider that sources from metadata in a RunStart document.
+
+    This uses metadata from a RunStart document to determine file names and data session
+    directories. The file naming defaults to "{device_name}-{instrument}-{scan_id}", so
+    the file name is incremented by scan number. A template can be included in the
+    StartDocument to allow for custom naming conventions.
+
+    """
+
+    def __init__(self) -> None:
+        self._doc = {}
+
+    def update_run(self, name: str, start_doc: RunStart) -> None:
+        """Cache a start document.
+
+        This can be plugged into the run engine's subscribe method.
+        """
+        if name == "start":
+            self._doc = start_doc
+
+    def __call__(self, device_name: str | None = None) -> PathInfo:
+        """Returns the directory path and filename for a given data_session.
+
+        The default template for file naming is: "{device_name}-{instrument}-{scan_id}"
+        however, this can be changed by providing a template in the start document. For
+        example: "template": "custom-{device_name}--{scan_id}".
+
+        If you do not provide a data_session_directory it will default to "/tmp".
+        """
+        template = self._doc.get("template", DEFAULT_TEMPLATE)
+        sub_path = template.format_map(self._doc | {"device_name": device_name})
+        data_session_directory = Path(self._doc.get("data_session_directory", "/tmp"))
+        return PathInfo(directory_path=data_session_directory, filename=sub_path)

dodal/devices/aperturescatterguard.py

@@ -12,7 +12,7 @@ from ophyd_async.core import (
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -123,7 +123,7 @@ def load_positions_from_beamline_parameters(
     }
 
 
-class ApertureScatterguard(StandardReadable, Movable, Preparable):
+class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable):
     """Move the aperture and scatterguard assembly in a safe way. There are two ways to
     interact with the device depending on if you want simplicity or move flexibility.
 
@@ -164,7 +164,7 @@ class ApertureScatterguard(StandardReadable, Movable, Preparable):
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = create_hardware_backed_soft_signal(
+        self.radius = create_r_hardware_backed_soft_signal(
             float, self._get_current_radius, units="µm"
         )
         self._loaded_positions = loaded_positions
@@ -181,7 +181,7 @@ class ApertureScatterguard(StandardReadable, Movable, Preparable):
         )
 
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.selected_aperture = create_hardware_backed_soft_signal(
+            self.selected_aperture = create_r_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
 

dodal/devices/apple2_undulator.py

@@ -1,7 +1,7 @@
 import abc
 import asyncio
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
@@ -21,6 +21,8 @@ from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
 
+T = TypeVar("T")
+
 
 class UndulatorGateStatus(StrictEnum):
     OPEN = "Open"
@@ -99,7 +101,7 @@ async def estimate_motor_timeout(
     return abs((target_pos - cur_pos) * 2.0 / vel) + 1
 
 
-class SafeUndulatorMover(StandardReadable, Movable):
+class SafeUndulatorMover(StandardReadable, Movable[T], Generic[T]):
     """A device that will check it's safe to move the undulator before moving it and
     wait for the undulator to be safe again before calling the move complete.
     """
@@ -115,7 +117,7 @@ class SafeUndulatorMover(StandardReadable, Movable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, value) -> None:
+    async def set(self, value: T) -> None:
         LOGGER.info(f"Setting {self.name} to {value}")
         await self.raise_if_cannot_move()
         await self._set_demand_positions(value)
@@ -125,7 +127,7 @@ class SafeUndulatorMover(StandardReadable, Movable):
         await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     @abc.abstractmethod
-    async def _set_demand_positions(self, value) -> None:
+    async def _set_demand_positions(self, value: T) -> None:
         """Set the demand positions on the device without actually hitting move."""
 
     @abc.abstractmethod
@@ -139,7 +141,7 @@ class SafeUndulatorMover(StandardReadable, Movable):
             raise RuntimeError(f"{self.name} is already in motion.")
 
 
-class UndulatorGap(SafeUndulatorMover):
+class UndulatorGap(SafeUndulatorMover[float]):
     """A device with a collection of epics signals to set Apple 2 undulator gap motion.
     Only PV used by beamline are added the full list is here:
     /dls_sw/work/R3.14.12.7/support/insertionDevice/db/IDGapVelocityControl.template
@@ -185,7 +187,7 @@ class UndulatorGap(SafeUndulatorMover):
             self.user_readback = epics_signal_r(float, prefix + "CURRGAPD")
         super().__init__(self.set_move, prefix, name)
 
-    async def _set_demand_positions(self, value) -> None:
+    async def _set_demand_positions(self, value: float) -> None:
         await self.user_setpoint.set(str(value))
 
     async def get_timeout(self) -> float:
@@ -234,7 +236,7 @@ class UndulatorPhaseMotor(StandardReadable):
         super().__init__(name=name)
 
 
-class UndulatorPhaseAxes(SafeUndulatorMover):
+class UndulatorPhaseAxes(SafeUndulatorMover[Apple2PhasesVal]):
     """
     A collection of 4 phase Motor to make up the full id phase motion. We are using the diamond pv convention.
     e.g. top_outer == Q1
@@ -290,7 +292,7 @@ class UndulatorPhaseAxes(SafeUndulatorMover):
         return np.max(timeouts)
 
 
-class UndulatorJawPhase(SafeUndulatorMover):
+class UndulatorJawPhase(SafeUndulatorMover[float]):
     """
     A JawPhase movable, this is use for moving the jaw phase which is use to control the
     linear arbitrary polarisation but only one some of the beamline.

dodal/devices/attenuator/attenuator.py

@@ -29,7 +29,7 @@ class ReadOnlyAttenuator(StandardReadable):
         super().__init__(name)
 
 
-class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable):
+class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
     In this attenuator, each filter can be in one of two states: IN or OUT
 

dodal/devices/backlight.py

@@ -15,7 +15,7 @@ class BacklightPosition(StrictEnum):
     OUT = "Out"
 
 
-class Backlight(StandardReadable, Movable):
+class Backlight(StandardReadable, Movable[BacklightPosition]):
     """Simple device to trigger the pneumatic in/out."""
 
     TIME_TO_MOVE_S = 1.0  # Tested using a stopwatch on the beamline 09/2024

dodal/devices/baton.py

@@ -0,0 +1,17 @@
+from typing import Annotated as A
+
+from ophyd_async.core import (
+    SignalRW,
+    StandardReadable,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+
+class Baton(StandardReadable, EpicsDevice):
+    requested_user: A[
+        SignalRW[str], PvSuffix("REQUESTED_USER"), Format.HINTED_UNCACHED_SIGNAL
+    ]
+    current_user: A[
+        SignalRW[str], PvSuffix("CURRENT_USER"), Format.HINTED_UNCACHED_SIGNAL
+    ]

dodal/devices/bimorph_mirror.py

@@ -41,7 +41,7 @@ class BimorphMirrorStatus(StrictEnum):
     ERROR = "Error"
 
 
-class BimorphMirrorChannel(StandardReadable, Movable, EpicsDevice):
+class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
     """Collection of PVs comprising a single bimorph channel.
 
     Attributes:
@@ -66,7 +66,7 @@ class BimorphMirrorChannel(StandardReadable, Movable, EpicsDevice):
         await self.output_voltage.set(value)
 
 
-class BimorphMirror(StandardReadable, Movable):
+class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
     """Class to represent CAENels Bimorph Mirrors.
 
     Attributes:

dodal/devices/current_amplifiers/current_amplifier.py

@@ -23,7 +23,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
         super().__init__(name)
 
     @abstractmethod
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         """Increase gain, increment by 1 by default.
 
@@ -31,7 +30,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def decrease_gain(self, value: int = 1) -> None:
         """Decrease gain, decrement by 1 by default.
@@ -40,21 +38,18 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
-    async def get_gain(self) -> type[Enum]:
+    async def get_gain(self) -> Enum:
         """Get the current gain setting
 
         Returns:
             Enum: The member name of the current gain setting in gain_conversion_table.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_upperlimit(self) -> float:
         """Get the upper limit of the current amplifier"""
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_lowerlimit(self) -> float:
         """Get the lower limit of the current amplifier"""

dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -92,8 +92,8 @@ class CurrentAmpDet(StandardReadable, Preparable):
             self.current_amp().get_gain(),
             self.counter().get_voltage_per_sec(),
         )
-        correction_factor = current_gain.value
-        corrected_current = voltage_per_sec / correction_factor
+        assert isinstance(current_gain.value, float)
+        corrected_current = voltage_per_sec / current_gain.value
         return corrected_current
 
     @AsyncStatus.wrap

dodal/devices/current_amplifiers/femto.py

@@ -114,7 +114,6 @@ class FemtoDDPCA(CurrentAmp):
         # wait for current amplifier's bandpass filter to settle.
         await asyncio.sleep(self.raise_timetable[SEN_setting].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -122,7 +121,6 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -130,14 +128,11 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         return self.gain_conversion_table[(await self.gain.get_value()).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/current_amplifiers/sr570.py

@@ -178,7 +178,6 @@ class SR570(CurrentAmp):
         )
         await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -189,7 +188,6 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -198,17 +196,14 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         result = await asyncio.gather(
             self.coarse_gain.get_value(), self.fine_gain.get_value()
         )
         return self.gain_conversion_table[self.combined_table(result).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/electron_analyser/base_region.py

@@ -0,0 +1,64 @@
+from enum import Enum
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class EnergyMode(str, Enum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"
+
+
+class BaseRegion(BaseModel):
+    """
+    Generic region model that holds the data. Specialised region models should inherit
+    this to extend functionality.
+    """
+
+    name: str = "New_region"
+    enabled: bool = False
+    slices: int = 1
+    iterations: int = 1
+    # These ones we need subclasses to provide default values
+    lensMode: str
+    passEnergy: int | float
+    acquisitionMode: str
+    lowEnergy: float
+    highEnergy: float
+    stepTime: float
+    energyStep: float
+    energyMode: EnergyMode = EnergyMode.KINETIC
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_energy_mode(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            # convert bindingEnergy to energyMode to make base region more generic
+            if "bindingEnergy" in data:
+                is_binding_energy = data["bindingEnergy"]
+                del data["bindingEnergy"]
+                data["energyMode"] = (
+                    EnergyMode.BINDING if is_binding_energy else EnergyMode.KINETIC
+                )
+        return data
+
+
+TBaseRegion = TypeVar("TBaseRegion", bound=BaseRegion)
+
+
+class BaseSequence(BaseModel, Generic[TBaseRegion]):
+    """
+    Generic sequence model that holds the list of region data. Specialised sequence models
+    should inherit this to extend functionality.
+    """
+
+    regions: list[TBaseRegion] = Field(default_factory=lambda: [])
+
+    def get_enabled_regions(self) -> list[BaseRegion]:
+        return [r for r in self.regions if r.enabled]
+
+    def get_region_names(self) -> list[str]:
+        return [r.name for r in self.regions]
+
+    def get_enabled_region_names(self) -> list[str]:
+        return [r.name for r in self.get_enabled_regions()]

dodal/devices/electron_analyser/specs/specs_region.py

@@ -0,0 +1,24 @@
+from pydantic import Field
+
+from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
+
+
+class SpecsRegion(BaseRegion):
+    # Override base class with defaults
+    lensMode: str = "SmallArea"
+    passEnergy: int | float = 5.0
+    acquisitionMode: str = "Fixed Transmission"
+    lowEnergy: float = Field(default=800, alias="startEnergy")
+    highEnergy: float = Field(default=850, alias="endEnergy")
+    stepTime: float = Field(default=1.0, alias="exposureTime")
+    energyStep: float = Field(default=0.1, alias="stepEnergy")
+    # Specific to this class
+    values: float = 1
+    centreEnergy: float = 0
+    psuMode: str = "1.5keV"
+    acquisitionMode: str = ""
+    estimatedTimeInMs: float = 0
+
+
+class SpecsSequence(BaseSequence):
+    regions: list[SpecsRegion] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/vgscienta/vgscienta_region.py

@@ -0,0 +1,77 @@
+import uuid
+from enum import Enum
+
+from ophyd_async.core import StrictEnum
+from pydantic import BaseModel, Field
+
+from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
+
+
+class Status(str, Enum):
+    READY = "Ready"
+    RUNNING = "Running"
+    COMPLETED = "Completed"
+    INVALID = "Invalid"
+    ABORTED = "Aborted"
+
+
+class DetectorMode(StrictEnum):
+    ADC = "ADC"
+    PULSE_COUNTING = "Pulse Counting"
+
+
+class AcquisitionMode(str, Enum):
+    SWEPT = "Swept"
+    FIXED = "Fixed"
+
+
+class VGScientaRegion(BaseRegion):
+    # Override defaults of base region class
+    lensMode: str = "Angular45"
+    passEnergy: int | float = 5
+    acquisitionMode: str = AcquisitionMode.SWEPT
+    lowEnergy: float = 8.0
+    highEnergy: float = 10.0
+    stepTime: float = 1.0
+    energyStep: float = Field(default=200.0)
+    # Specific to this class
+    regionId: str = Field(default=str(uuid.uuid4()))
+    excitationEnergySource: str = "source1"
+    fixEnergy: float = 9.0
+    totalSteps: float = 13.0
+    totalTime: float = 13.0
+    exposureTime: float = 1.0
+    firstXChannel: int = 1
+    lastXChannel: int = 1000
+    firstYChannel: int = 101
+    lastYChannel: int = 800
+    detectorMode: DetectorMode = DetectorMode.ADC
+    status: Status = Status.READY
+
+
+class VGScientaExcitationEnergySource(BaseModel):
+    name: str = "source1"
+    scannableName: str = ""
+    value: float = 0
+
+
+class VGScientaSequence(BaseSequence):
+    elementSet: str = Field(default="Unknown")
+    excitationEnergySources: list[VGScientaExcitationEnergySource] = Field(
+        default_factory=lambda: []
+    )
+    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
+
+    def get_excitation_energy_source_by_region(
+        self, region: VGScientaRegion
+    ) -> VGScientaExcitationEnergySource | None:
+        filtered_excitation_energy_sources = [
+            e
+            for e in self.excitationEnergySources
+            if e.name == region.excitationEnergySource
+        ]
+        return (
+            filtered_excitation_energy_sources[0]
+            if len(filtered_excitation_energy_sources) == 1
+            else None
+        )

dodal/devices/fast_grid_scan.py

@@ -23,7 +23,7 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,7 +203,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_hardware_backed_soft_signal(
+        self.expected_images = create_r_hardware_backed_soft_signal(
             float, self._calculate_expected_images
         )
 

dodal/devices/hutch_shutter.py

@@ -55,7 +55,7 @@ class HutchInterlock(StandardReadable):
         return interlock_state == HUTCH_SAFE_FOR_OPERATIONS
 
 
-class HutchShutter(StandardReadable, Movable):
+class HutchShutter(StandardReadable, Movable[ShutterDemand]):
     """Device to operate the hutch shutter.
 
     When a demand is sent, the device should first check the hutch status \

dodal/devices/i03/beamstop.py

@@ -5,7 +5,7 @@ from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class BeamstopPositions(StrictEnum):
@@ -53,7 +53,7 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = create_hardware_backed_soft_signal(
+            self.selected_pos = create_r_hardware_backed_soft_signal(
                 BeamstopPositions, self._get_selected_position
             )
 

dodal/devices/i10/i10_apple2.py

@@ -175,7 +175,7 @@ class I10Apple2(Apple2):
         self._available_pol = list(self.lookup_tables["Gap"].keys())
 
 
-class I10Apple2PGM(StandardReadable, Movable):
+class I10Apple2PGM(StandardReadable, Movable[float]):
     """
     Compound device to set both ID and PGM energy at the sample time,poly_deg
 
@@ -211,7 +211,7 @@ class I10Apple2PGM(StandardReadable, Movable):
         )
 
 
-class I10Apple2Pol(StandardReadable, Movable):
+class I10Apple2Pol(StandardReadable, Movable[str]):
     """
     Compound device to set polorisation of ID.
     """
@@ -240,7 +240,7 @@ class I10Apple2Pol(StandardReadable, Movable):
         )  # Move id to new polarisation
 
 
-class LinearArbitraryAngle(StandardReadable, Movable):
+class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
     """
     Device to set polorisation angle of the ID. Linear Arbitrary Angle (laa)
      is the direction of the magnetic field which can be change by varying the jaw_phase