dls-dodal 1.68.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/{i19 → beamlines/i19}/access_controlled/attenuator_motor_squad.py

@@ -4,10 +4,12 @@ from ophyd_async.core import AsyncStatus
 from pydantic import BaseModel, model_validator
 from pydantic.types import PositiveInt, StringConstraints
 
-from dodal.devices.i19.access_controlled.blueapi_device import (
+from dodal.devices.beamlines.i19.access_controlled.blueapi_device import (
     OpticsBlueAPIDevice,
 )
-from dodal.devices.i19.access_controlled.hutch_access import ACCESS_DEVICE_NAME
+from dodal.devices.beamlines.i19.access_controlled.hutch_access import (
+    ACCESS_DEVICE_NAME,
+)
 
 PermittedKeyStr = Annotated[str, StringConstraints(pattern="^[A-Za-z0-9-_]*$")]
 
@@ -32,18 +34,20 @@ class AttenuatorMotorPositionDemands(BaseModel):
 
 
 class AttenuatorMotorSquad(OpticsBlueAPIDevice):
-    """ I19-specific proxy device which requests absorber position changes in the x-ray attenuator.
+    """I19-specific proxy device which requests absorber position changes in the
+    x-ray attenuator.
 
     Sends REST call to blueapi controlling optics on the I19 cluster.
-     The hutch in use is compared against the hutch which sent the REST call.
+    The hutch in use is compared against the hutch which sent the REST call.
     Only the hutch in use will be permitted to execute a plan (requesting motor moves).
-    As the two hutches are located in series, checking the hutch in use is necessary to \
-    avoid accidentally operating optics devices from one hutch while the other has beam time.
+    As the two hutches are located in series, checking the hutch in use is necessary to
+    avoid accidentally operating optics devices from one hutch while the other has beam
+    time.
 
-    The name of the hutch that wants to operate the optics device is passed to the \
+    The name of the hutch that wants to operate the optics device is passed to the
     access controlled device upon instantiation of the latter.
 
-    For details see the architecture described in \
+    For details see the architecture described in
     https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 

dodal/devices/{i19 → beamlines/i19}/access_controlled/blueapi_device.py

@@ -21,11 +21,11 @@ class HutchState(str, Enum):
 
 
 class OpticsBlueAPIDevice(StandardReadable, Movable[D]):
-    """General device that a REST call to the blueapi instance controlling the optics \
-    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    """General device that a REST call to the blueapi instance controlling the optics
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs
     the hutch sending the request and decide if the plan will be run or not.
 
-    For details see the architecture described in \
+    For details see the architecture described in
     https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
@@ -44,22 +44,23 @@ class OpticsBlueAPIDevice(StandardReadable, Movable[D]):
 
     @AsyncStatus.wrap
     async def set(self, value: D):
-        """ On set send a POST request to the optics blueapi with the name and \
-        parameters, gets the generated task_id and then sends a PUT request that runs \
+        """On set send a POST request to the optics blueapi with the name and
+        parameters, gets the generated task_id and then sends a PUT request that runs
         the plan.
 
         Args:
-            value (dict): The value passed here should be the parameters for the POST \
-                request, taking the form:
-                {
-                    "name": "plan_name",
-                    "params": {
-                        "experiment_hutch": f"{hutch_name}",
-                        "access_device": "access_control",
-                        "other_params": "...",
-                        ...
+            value (dict): The value passed here should be the parameters for the POST
+                request, taking the form::
+
+                    {
+                        "name": "plan_name",
+                        "params": {
+                            "experiment_hutch": f"{hutch_name}",
+                            "access_device": "access_control",
+                            "other_params": "...",
+                            ...
+                        }
                     }
-                }
         """
         # Value here vould be request params dictionary.
         request_params = json.dumps(value)

dodal/devices/beamlines/i19/access_controlled/piezo_control.py

@@ -0,0 +1,72 @@
+from enum import StrEnum
+
+from ophyd_async.core import AsyncStatus, StandardReadableFormat
+from ophyd_async.epics.core import epics_signal_r
+
+from dodal.devices.beamlines.i19.access_controlled.blueapi_device import (
+    HutchState,
+    OpticsBlueAPIDevice,
+)
+from dodal.devices.beamlines.i19.access_controlled.hutch_access import (
+    ACCESS_DEVICE_NAME,
+)
+
+
+class FocusingMirrorName(StrEnum):
+    VFM = "vfm"
+    HFM = "hfm"
+
+
+PIEZO_CONTROL_PLAN_NAME = "apply_voltage_to_piezo"
+
+
+# NOTE This device is only meant to control the piezo. There should be a separate device
+# to control the actual focusing mirror motors, as the two operations are often done
+# independently.
+class AccessControlledPiezoActuator(OpticsBlueAPIDevice):
+    """I19-specific device to set a voltage on the focusing mirror piezoelectric
+    actuator.
+
+    This device will send a REST call to the blueapi instance controlling the optics
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs
+    the hutch sending the request and decide if the plan will be run or not.
+    As the two hutches are located in series, checking the hutch in use is necessary to
+    avoid accidentally operating the shutter from one hutch while the other has beamtime.
+
+    The name of the hutch that wants to operate the shutter, as well as a commissioning
+    directory to act as a placehlder for the instrument_session,should be passed to the
+    device upon instantiation.
+
+    A mirror type (vfm or hfm) also needs to be set upon instantiation so that the
+    correct plan can be run and the correct optics device is injected.
+
+    For details see the architecture described in
+    https://diamondlightsource.github.io/i19-bluesky/main/explanations/decisions/0004-optics-blueapi-architecture.html
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        mirror_type: FocusingMirrorName,
+        hutch: HutchState,
+        instrument_session: str = "",
+        name: str = "",
+    ):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.readback = epics_signal_r(float, f"{prefix}AOFPITCH:RBV")
+        self.mirror = mirror_type
+        super().__init__(hutch=hutch, instrument_session=instrument_session, name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        request_params = {
+            "name": PIEZO_CONTROL_PLAN_NAME,
+            "params": {
+                "experiment_hutch": self._invoking_hutch,
+                "access_device": ACCESS_DEVICE_NAME,
+                "voltage_demand": value,
+                "focus_mirror": self.mirror.value,
+            },
+            "instrument_session": self.instrument_session,
+        }
+        await super().set(request_params)

dodal/devices/{i19 → beamlines/i19}/access_controlled/shutter.py

@@ -1,27 +1,29 @@
 from ophyd_async.core import AsyncStatus, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
-from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
-from dodal.devices.i19.access_controlled.blueapi_device import (
+from dodal.devices.beamlines.i19.access_controlled.blueapi_device import (
     HutchState,
     OpticsBlueAPIDevice,
 )
-from dodal.devices.i19.access_controlled.hutch_access import ACCESS_DEVICE_NAME
+from dodal.devices.beamlines.i19.access_controlled.hutch_access import (
+    ACCESS_DEVICE_NAME,
+)
+from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
 
 
 class AccessControlledShutter(OpticsBlueAPIDevice):
-    """ I19-specific device to operate the hutch shutter.
+    """I19-specific device to operate the hutch shutter.
 
-    This device will send a REST call to the blueapi instance controlling the optics \
-    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    This device will send a REST call to the blueapi instance controlling the optics
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs
     the hutch sending the request and decide if the plan will be run or not.
-    As the two hutches are located in series, checking the hutch in use is necessary to \
+    As the two hutches are located in series, checking the hutch in use is necessary to
     avoid accidentally operating the shutter from one hutch while the other has beamtime.
 
-    The name of the hutch that wants to operate the shutter should be passed to the \
+    The name of the hutch that wants to operate the shutter should be passed to the
     device upon instantiation.
 
-    For details see the architecture described in \
+    For details see the architecture described in
     https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 

dodal/devices/{i19 → beamlines/i19}/backlight.py

@@ -6,7 +6,9 @@ from dodal.common.enums import InOutUpper
 
 
 class BacklightPosition(StandardReadable, Movable[InOutUpper]):
-    """Device moves backlight to the IN or OUT position since controls side manages switching the light on/off"""
+    """Device moves backlight to the IN or OUT position since controls side manages
+    switching the light on/off.
+    """
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.position = epics_signal_rw(InOutUpper, f"{prefix}AD1:choiceButton")

dodal/devices/{i19 → beamlines/i19}/mapt_configuration.py

@@ -27,7 +27,8 @@ class MAPTConfigurationTable(StandardReadable):
 class MAPTConfigurationControl(StandardReadable):
     """A device to control the MAPT (Mini Aperture) configuration. It provides a signal
     to set the configuration PV to the requested value and a triggerable signal that
-    will move all the motors to the correct position."""
+    will move all the motors to the correct position.
+    """
 
     def __init__(
         self, prefix: str, aperture_request: type[SubsetEnum], name: str = ""

dodal/devices/{i19 → beamlines/i19}/pin_col_stages.py

@@ -6,7 +6,7 @@ from ophyd_async.core import AsyncStatus, StandardReadable, SubsetEnum
 from ophyd_async.epics.core import epics_signal_r
 from pydantic import BaseModel
 
-from dodal.devices.i19.mapt_configuration import (
+from dodal.devices.beamlines.i19.mapt_configuration import (
     MAPTConfigurationControl,
     MAPTConfigurationTable,
 )
@@ -45,10 +45,10 @@ class AperturePosition(BaseModel):
     one of the available apertures.
 
     Attributes:
-        pinhole_x: The position of the x motor on the pinhole stage
-        pinhole_y: The position of the y motor on the pinhole stage
-        collimator_x: The position of the x motor on the collimator stage
-        collimator_y: The position of the y motor on the collimator stage
+        pinhole_x (float): The position of the x motor on the pinhole stage.
+        pinhole_y (float): The position of the y motor on the pinhole stage.
+        collimator_x (float): The position of the x motor on the collimator stage.
+        collimator_y (float): The position of the y motor on the collimator stage.
     """
 
     pinhole_x: float
@@ -59,7 +59,8 @@ class AperturePosition(BaseModel):
 
 class PinColConfiguration(StandardReadable):
     """Full MAPT configuration table, including out positions and selection for the
-    Pinhole and Collimator control."""
+    Pinhole and Collimator control.
+    """
 
     def __init__(self, prefix: str, apertures: list[int], name: str = "") -> None:
         with self.add_children_as_readables():
@@ -75,7 +76,8 @@ class PinColConfiguration(StandardReadable):
 
 class PinholeCollimatorControl(StandardReadable, Movable[str]):
     """Device to control the Pinhole and Collimator stages moves on I19-2, using the
-    MAPT configuration table to look up the positions."""
+    MAPT configuration table to look up the positions.
+    """
 
     def __init__(
         self,
@@ -130,7 +132,8 @@ class PinholeCollimatorControl(StandardReadable, Movable[str]):
     async def _safe_move_in(self, value: _PinColPosition):
         """Move the pinhole and collimator stages safely to the in position.
         In order to avoid a collision, we have to make sure that the pinhole stage is
-        always moved in before the collimator stage."""
+        always moved in before the collimator stage.
+        """
         LOGGER.info(
             f"Moving pinhole and collimator stages to in position: {value.value}"
         )

dodal/devices/beamlines/i19/pin_tip.py

@@ -0,0 +1,32 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class PinTipCentreHolder(StandardReadable):
+    """Temporary device to hold the pin tip x,y positions for centring.
+    It uses the CenterX and CenterY PVs in the overlay plugin for the OAV device to
+    save and read the pit tip location.
+
+    Attributes:
+        pin_tip_i (SignalRW): x position of the pin tip, in pixels.
+        pin_tip_j (SignalRW): y position of the pin tip, in pixels.
+
+    This workaround is necessary because it's not yet possible to get these values back
+    from a plan in blueapi. It will be removed once this is completed
+    https://github.com/DiamondLightSource/blueapi/issues/1349
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        overlay_channel: int = 1,
+    ):
+        with self.add_children_as_readables():
+            self.pin_tip_i = epics_signal_rw(
+                int, prefix + f"OVER:{overlay_channel}:CenterX"
+            )
+            self.pin_tip_j = epics_signal_rw(
+                int, prefix + f"OVER:{overlay_channel}:CenterY"
+            )
+        super().__init__(name)

dodal/devices/beamlines/i21/__init__.py

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

dodal/devices/{i22 → beamlines/i22}/dcm.py

@@ -24,8 +24,7 @@ _CONVERSION_CONSTANT = 12.3984
 
 
 class DCM(DoubleCrystalMonochromatorWithDSpacing[RollCrystal, PitchAndRollCrystal]):
-    """
-    A double crystal monochromator (DCM), used to select the energy of the beam.
+    """A double crystal monochromator (DCM), used to select the energy of the beam.
 
     perp describes the gap between the 2 DCM crystals which has to change as you alter
     the angle to select the requested energy.

dodal/devices/{i22 → beamlines/i22}/fswitch.py

@@ -15,8 +15,7 @@ from dodal.common.enums import InOutUpper
 
 
 class FSwitch(StandardReadable):
-    """
-    Device for i22's fswitch. A filter switch for manipulating
+    """Device for i22's fswitch. A filter switch for manipulating
     compound refractive lenses. Also referred to as a transfocator.
 
     This currently only implements the minimum
@@ -25,7 +24,6 @@ class FSwitch(StandardReadable):
     Eventually this should be combined with the transfocator device in the i04
     module but is currently incompatible as the Epics interfaces are different.
     See https://github.com/DiamondLightSource/dodal/issues/399
-
     """
 
     NUM_FILTERS = 128

dodal/devices/{i22 → beamlines/i22}/nxsas.py

@@ -57,8 +57,7 @@ class MetadataHolder:
 
 @dataclass
 class NXSasMetadataHolder(MetadataHolder):
-    """
-    Required fields for NXDetectors that are used in an NXsas application definition.
+    """Required fields for NXDetectors that are used in an NXsas application definition.
     All fields are Configuration and read once per run only.
     """
 
@@ -94,7 +93,8 @@ class NXSasPilatus(PilatusDetector):
         to comply with the NXsas application definition.
         Adds all values in the NXSasMetadataHolder's configuration fields
         to the configuration of the parent device.
-        Writes hdf5 files."""
+        Writes hdf5 files.
+        """
         super().__init__(
             prefix,
             path_provider,
@@ -137,7 +137,8 @@ class NXSasOAV(AravisDetector):
         to comply with the NXsas application definition.
         Adds all values in the NXSasMetadataHolder's configuration fields
         to the configuration of the parent device.
-        Writes hdf5 files."""
+        Writes hdf5 files.
+        """
         super().__init__(
             prefix,
             path_provider,

dodal/devices/{i24 → beamlines/i24}/beam_center.py

@@ -1,4 +1,4 @@
-"""A small temporary device to get the beam center positions on i24"""
+"""A small temporary device to get the beam center positions on i24."""
 
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_rw

dodal/devices/{i24 → beamlines/i24}/beamstop.py

@@ -21,8 +21,8 @@ class Beamstop(XYZStage):
     The additional y_rotation motor is independent of the positioner and can to be moved
     on its own as needed.
 
-    WARNING. Before moving the y_rotation motor away from 0, it is important to make sure
-    that the backlight is in the "OUT" position to avoid a collision.
+    WARNING. Before moving the y_rotation motor away from 0, it is important to make
+    sure that the backlight is in the "OUT" position to avoid a collision.
     See also https://github.com/DiamondLightSource/dodal/issues/646.
     """
 

dodal/devices/{i24 → beamlines/i24}/commissioning_jungfrau.py

@@ -6,11 +6,10 @@ from bluesky.protocols import StreamAsset
 from event_model import DataKey  # type: ignore
 from ophyd_async.core import (
     AsyncStatus,
-    AutoIncrementingPathProvider,
     DetectorWriter,
+    PathProvider,
     StandardDetector,
     StandardReadable,
-    StaticPathProvider,
     TriggerInfo,
     observe_value,
     wait_for_value,
@@ -22,22 +21,22 @@ from ophyd_async.fastcs.jungfrau._signals import JungfrauDriverIO
 from dodal.log import LOGGER
 
 
-class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
+class JungfrauCommissioningWriter(DetectorWriter, StandardReadable):
     """Implementation of the temporary filewriter used for Jungfrau commissioning on i24.
 
     The PVs on this device are responsible for writing files of a specified name
     to a specified path, marking itself as "ready to write", and having a counter of
-    frames written, which must be zero'd at the ophyd level
+    frames written, which must be zero'd at the ophyd level.
     """
 
     def __init__(
         self,
         prefix,
-        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        path_provider: PathProvider,
         name="",
     ) -> None:
         with self.add_children_as_readables():
-            self._path_info = path_provider
+            self._path_provider = path_provider
             self.frame_counter = epics_signal_rw(int, f"{prefix}NumCaptured")
             self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
             self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
@@ -47,9 +46,8 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
         self._exposures_per_event = exposures_per_event
-        _path_info = self._path_info()
+        _path_info = self._path_provider()
 
-        # Commissioning Jungfrau plans allow you to override path, so check to see if file exists
         requested_filepath = Path(_path_info.directory_path) / _path_info.filename
         if requested_filepath.exists():
             raise FileExistsError(
@@ -65,6 +63,7 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
             f"Jungfrau writing to folder {_path_info.directory_path} with filename {_path_info.filename}"
         )
         await wait_for_value(self.writer_ready, 1, timeout=10)
+        self.final_path = requested_filepath
         return await self._describe()
 
     async def _describe(self) -> dict[str, DataKey]:
@@ -99,20 +98,21 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
 
 
 class CommissioningJungfrau(
-    StandardDetector[JungfrauController, JunfrauCommissioningWriter]
+    StandardDetector[JungfrauController, JungfrauCommissioningWriter]
 ):
     """Ophyd-async implementation of a Jungfrau 9M Detector, using a temporary
-    filewriter in place of Odin"""
+    filewriter in place of Odin.
+    """
 
     def __init__(
         self,
         prefix: str,
         writer_prefix: str,
-        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        path_provider: PathProvider,
         name="",
     ):
         self.drv = JungfrauDriverIO(prefix)
-        writer = JunfrauCommissioningWriter(writer_prefix, path_provider)
+        writer = JungfrauCommissioningWriter(writer_prefix, path_provider)
         controller = JungfrauController(self.drv)
         super().__init__(controller, writer, name=name)
 

dodal/devices/{i24 → beamlines/i24}/dcm.py

@@ -8,9 +8,7 @@ from dodal.devices.common_dcm import (
 
 
 class DCM(DoubleCrystalMonochromatorWithDSpacing[RollCrystal, PitchAndRollCrystal]):
-    """
-    A double crystal monocromator device, used to select the beam energy.
-    """
+    """A double crystal monocromator device, used to select the beam energy."""
 
     def __init__(self, prefix: str, motion_prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():

dodal/devices/{i24 → beamlines/i24}/dual_backlight.py

@@ -27,13 +27,13 @@ class BacklightPositioner(StandardReadable):
 
 
 class DualBacklight(StandardReadable):
-    """
-    Device to trigger the dual backlight on I24.
+    """Device to trigger the dual backlight on I24.
     This device is made up by two LEDs:
         - LED1 is the "backlight", can be moved to 5 different positions.
         - LED2 is a "frontlight", it does not move, just switches on and off.
 
-    To set the position for LED1:
+    To set the position for LED1::
+
         b = DualBacklight(name="backlight)
         b.backlight_position.set("OAV2")
 

dodal/devices/{i24 → beamlines/i24}/pmac.py

@@ -45,9 +45,11 @@ class LaserSettings(str, Enum):
 class EncReset(str, Enum):
     """PMAC strings for position compare on encoder channels in the controller.
 
-    For example, for ENC5:
+    For example, for ENC5::
+
         m508 sets position A to be compared with value in Channel5 in the controller.
         m509 sets position B to be compared with value in Channel5 in the controller.
+
     Note. These settings are usually used for initialisation.
     """
 
@@ -141,8 +143,8 @@ class ProgramRunner(Device, Flyable):
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        """Kick off the collection by sending a program number to the pmac_string and \
-            wait for the scan status PV to go to 1.
+        """Kick off the collection by sending a program number to the pmac_string and
+        wait for the scan status PV to go to 1.
         """
         prog_num_str = await self._get_prog_number_string()
         await self._signal_ref().set(prog_num_str, wait=True)
@@ -154,8 +156,8 @@ class ProgramRunner(Device, Flyable):
 
     @AsyncStatus.wrap
     async def complete(self):
-        """Stop collecting when the scan status PV goes to 0 or when counter PV hasn't \
-            updated for 30 seconds.
+        """Stop collecting when the scan status PV goes to 0 or when counter PV hasn't
+        updated for 30 seconds.
         """
         counter_time = await self._counter_time_ref().get_value()
         async for signal, value in observe_signals_value(
@@ -169,8 +171,8 @@ class ProgramRunner(Device, Flyable):
 
 
 class ProgramAbort(Triggerable):
-    """Abort a data collection by setting the PMAC string and then wait for the \
-        status value to go back to 0.
+    """Abort a data collection by setting the PMAC string and then wait for the
+    status value to go back to 0.
     """
 
     def __init__(

dodal/devices/{p60 → beamlines/p60}/lab_xray_source.py

@@ -12,7 +12,7 @@ class LabXraySource(float, Enum):
 
 
 class LabXraySourceReadable(StandardReadable):
-    """Simple device to get the laboratory x-ray tube energy reading"""
+    """Simple device to get the laboratory x-ray tube energy reading."""
 
     def __init__(self, xraysource: LabXraySource, name: str = "") -> None:
         with self.add_children_as_readables():

dodal/devices/{p99 → beamlines/p99}/andor2_point.py

@@ -8,7 +8,17 @@ 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."""
+    value after a picture is taken.
+
+    Args:
+        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 ([dict[str, NDPluginBaseIO], optional): Dictionary containing
+            plugin that are forward to the base class.
+    """
 
     def __init__(
         self,
@@ -18,20 +28,6 @@ class Andor2Point(SingleTriggerDetector):
         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))