ophyd-async 0.9.0a1__py3-none-any.whl → 0.9.0a2__py3-none-any.whl

ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,58 +1,46 @@
-from enum import Enum
+from collections.abc import Sequence
 
-from bluesky.protocols import Hints
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
+from ophyd_async.epics.adcore._core_detector import AreaDetector
+from ophyd_async.epics.adcore._core_io import NDPluginBaseIO
+from ophyd_async.epics.adcore._core_writer import ADWriter
+from ophyd_async.epics.adcore._hdf_writer import ADHDFWriter
 
-from ophyd_async.core import PathProvider, StandardDetector
-from ophyd_async.epics import adcore
-
-from ._pilatus_controller import PilatusController
+from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO
 
 
-#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-#: The required minimum time difference between ExpPeriod and ExpTime
-#: (readout time) is 2.28 ms
-#: We provide an option to override for newer Pilatus models
-class PilatusReadoutTime(float, Enum):
-    """Pilatus readout time per model in ms"""
-
-    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-    PILATUS2 = 2.28e-3
-
-    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
-    PILATUS3 = 0.95e-3
-
-
-class PilatusDetector(StandardDetector):
+class PilatusDetector(AreaDetector[PilatusController]):
     """A Pilatus StandardDetector writing HDF files"""
 
-    _controller: PilatusController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         readout_time: PilatusReadoutTime = PilatusReadoutTime.PILATUS3,
         drv_suffix: str = "cam1:",
-        hdf_suffix: str = "HDF1:",
+        writer_cls: type[ADWriter] = ADHDFWriter,
+        fileio_suffix: str | None = None,
         name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = PilatusDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = PilatusDriverIO(prefix + drv_suffix)
+        controller = PilatusController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            PilatusController(self.drv, readout_time=readout_time.value),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,9 +1,9 @@
 import asyncio
+from enum import Enum
+from typing import TypeVar, get_args
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
     wait_for_value,
@@ -13,7 +13,24 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-class PilatusController(DetectorController):
+#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+#: The required minimum time difference between ExpPeriod and ExpTime
+#: (readout time) is 2.28 ms
+#: We provide an option to override for newer Pilatus models
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms"""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    PILATUS2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    PILATUS3 = 0.95e-3
+
+
+PilatusControllerT = TypeVar("PilatusControllerT", bound="PilatusController")
+
+
+class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
     _supported_trigger_types = {
         DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
         DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
@@ -23,48 +40,56 @@ class PilatusController(DetectorController):
     def __init__(
         self,
         driver: PilatusDriverIO,
-        readout_time: float,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        readout_time: float = PilatusReadoutTime.PILATUS3,
     ) -> None:
-        self._drv = driver
+        super().__init__(driver, good_states=good_states)
         self._readout_time = readout_time
-        self._arm_status: AsyncStatus | None = None
+
+    @classmethod
+    def controller_and_drv(
+        cls: type[PilatusControllerT],
+        prefix: str,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        name: str = "",
+        readout_time: float = PilatusReadoutTime.PILATUS3,
+    ) -> tuple[PilatusControllerT, PilatusDriverIO]:
+        driver_cls = get_args(cls.__orig_bases__[0])[0]  # type: ignore
+        driver = driver_cls(prefix, name=name)
+        controller = cls(driver, good_states=good_states, readout_time=readout_time)
+        return controller, driver
 
     def get_deadtime(self, exposure: float | None) -> float:
         return self._readout_time
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.livetime is not None:
-            await adcore.set_exposure_time_and_acquire_period_if_supplied(
-                self, self._drv, trigger_info.livetime
+            await self.set_exposure_time_and_acquire_period_if_supplied(
+                trigger_info.livetime
             )
         await asyncio.gather(
-            self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
-            self._drv.num_images.set(
+            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.num_images.set(
                 999_999
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):
         # Standard arm the detector and wait for the acquire PV to be True
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed,
+            self.driver.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )
 
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
         if trigger not in cls._supported_trigger_types.keys():
@@ -74,6 +99,3 @@ class PilatusController(DetectorController):
                 f"use {trigger}"
             )
         return cls._supported_trigger_types[trigger]
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adsimdetector/__init__.py

@@ -1,7 +1,7 @@
-from ._sim import SimDetector
-from ._sim_controller import SimController
+from ._sim import SimController, SimDetector, SimDriverIO
 
 __all__ = [
-    "SimDetector",
+    "SimDriverIO",
     "SimController",
+    "SimDetector",
 ]

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,35 +1,51 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
-from ._sim_controller import SimController
 
+class SimDriverIO(adcore.ADBaseIO): ...
 
-class SimDetector(StandardDetector):
-    _controller: SimController
-    _writer: adcore.ADHDFWriter
 
+class SimController(adcore.ADBaseController[SimDriverIO]):
+    def __init__(
+        self,
+        driver: SimDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+    ) -> None:
+        super().__init__(driver, good_states=good_states)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0.001
+
+
+class SimDetector(adcore.AreaDetector[SimController]):
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name: str = "",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name="",
         config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
-        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = SimDriverIO(prefix + drv_suffix)
+        controller = SimController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            SimController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )

ophyd_async/epics/advimba/_vimba.py

@@ -1,43 +1,43 @@
-from bluesky.protocols import HasHints, Hints
+from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._vimba_controller import VimbaController
 from ._vimba_io import VimbaDriverIO
 
 
-class VimbaDetector(StandardDetector, HasHints):
+class VimbaDetector(adcore.AreaDetector[VimbaController]):
     """
     Ophyd-async implementation of an ADVimba Detector.
     """
 
-    _controller: VimbaController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        drv_suffix: str = "cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = VimbaDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = VimbaDriverIO(prefix + drv_suffix)
+        controller = VimbaController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            VimbaController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,8 +1,6 @@
 import asyncio
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
 )
@@ -25,42 +23,30 @@ EXPOSE_OUT_MODE = {
 }
 
 
-class VimbaController(DetectorController):
+class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
     def __init__(
         self,
         driver: VimbaDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
-        self._drv = driver
-        self._arm_status: AsyncStatus | None = None
+        super().__init__(driver, good_states=good_states)
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
     async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
-            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
-            self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
+            self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.VARIABLE_GATE,
             DetectorTrigger.CONSTANT_GATE,
         ]:
-            await self._drv.acquire_time.set(trigger_info.livetime)
+            await self.driver.acquire_time.set(trigger_info.livetime)
         if trigger_info.trigger != DetectorTrigger.INTERNAL:
-            self._drv.trigger_source.set(VimbaTriggerSource.LINE1)
+            self.driver.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.FREERUN)
-
-    async def arm(self):
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
-
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
+            self.driver.trigger_source.set(VimbaTriggerSource.FREERUN)

ophyd_async/epics/core/_aioca.py

@@ -35,12 +35,14 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
         high = getattr(value, f"upper_{limit}_limit", nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not high == low == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -59,14 +61,20 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
 
 
 def _metadata_from_augmented_value(
-    value: AugmentedValue, metadata: SignalMetadata
+    datatype: type[SignalDatatypeT] | None,
+    value: AugmentedValue,
+    metadata: SignalMetadata,
 ) -> SignalMetadata:
     metadata = metadata.copy()
-    if hasattr(value, "units"):
+    if hasattr(value, "units") and datatype not in (str, bool):
         metadata["units"] = value.units
-    if hasattr(value, "precision") and not isnan(value.precision):
+    if (
+        hasattr(value, "precision")
+        and not isnan(value.precision)
+        and datatype is not int
+    ):
         metadata["precision"] = value.precision
-    if limits := _limits_from_augmented_value(value):
+    if (limits := _limits_from_augmented_value(value)) and datatype is not bool:
         metadata["limits"] = limits
     return metadata
 
@@ -100,6 +108,11 @@ class DisconnectedCaConverter(CaConverter):
         raise NotImplementedError("No PV has been set as connect() has not been called")
 
 
+class CaIntConverter(CaConverter[int]):
+    def value(self, value: AugmentedValue) -> int:
+        return int(value)  # type: ignore
+
+
 class CaArrayConverter(CaConverter[np.ndarray]):
     def value(self, value: AugmentedValue) -> np.ndarray:
         # A less expensive conversion
@@ -202,7 +215,7 @@ def make_converter(
         and get_unique({k: v.precision for k, v in values.items()}, "precision") == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return CaConverter(int, pv_dbr)
+        return CaIntConverter(int, pv_dbr)
     elif datatype in (None, inferred_datatype):
         # If datatype matches what we are given then allow it and use inferred converter
         return converter_cls(inferred_datatype, pv_dbr)
@@ -247,7 +260,7 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
                 pv, format=FORMAT_CTRL, timeout=timeout
             )
         except CANothing as exc:
-            logging.debug(f"signal ca://{pv} timed out")
+            logger.debug(f"signal ca://{pv} timed out")
             raise NotConnected(f"ca://{pv}") from exc
 
     async def connect(self, timeout: float):
@@ -290,7 +303,9 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(self.read_pv, FORMAT_CTRL)
-        metadata = _metadata_from_augmented_value(value, self.converter.metadata)
+        metadata = _metadata_from_augmented_value(
+            self.datatype, value, self.converter.metadata
+        )
         return make_datakey(
             self.converter.datatype, self.converter.value(value), source, metadata
         )
@@ -308,16 +323,18 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
             self.subscription = camonitor(
                 self.read_pv,
                 lambda v: callback(self._make_reading(v)),
                 datatype=self.converter.read_dbr,
                 format=FORMAT_TIME,
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

ophyd_async/epics/core/_p4p.py

@@ -31,6 +31,8 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_value(value: Any) -> Limits:
     def get_limits(
@@ -39,7 +41,7 @@ def _limits_from_value(value: Any) -> Limits:
         substructure = getattr(value, substucture_name, None)
         low = getattr(substructure, low_name, nan)
         high = getattr(substructure, high_name, nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not low == high == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -60,12 +62,22 @@ def _limits_from_value(value: Any) -> Limits:
 def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMetadata:
     metadata = SignalMetadata()
     value_data: Any = getattr(value, "value", None)
+    specifier = _get_specifier(value)
     display_data: Any = getattr(value, "display", None)
-    if hasattr(display_data, "units"):
+    if (
+        hasattr(display_data, "units")
+        and specifier[-1] in _number_specifiers
+        and datatype is not str
+    ):
         metadata["units"] = display_data.units
-    if hasattr(display_data, "precision") and not isnan(display_data.precision):
+    if (
+        hasattr(display_data, "precision")
+        and not isnan(display_data.precision)
+        and specifier[-1] in _float_specifiers
+        and datatype is not int
+    ):
         metadata["precision"] = display_data.precision
-    if limits := _limits_from_value(value):
+    if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
     if datatype is str or issubclass(datatype, StrictEnum):
@@ -84,9 +96,7 @@ class PvaConverter(Generic[SignalDatatypeT]):
         self.datatype = datatype
 
     def value(self, value: Any) -> SignalDatatypeT:
-        # for channel access ca_xxx classes, this
-        # invokes __pos__ operator to return an instance of
-        # the builtin base class
+        # Normally the value will be of the correct python type
         return value["value"]
 
     def write_value(self, value: Any) -> Any:
@@ -94,6 +104,15 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaIntConverter(PvaConverter[int]):
+    def __init__(self):
+        super().__init__(int)
+
+    def value(self, value: Any) -> int:
+        # Convert to an int
+        return int(value["value"])
+
+
 class PvaLongStringConverter(PvaConverter[str]):
     def __init__(self):
         super().__init__(str)
@@ -174,6 +193,9 @@ class PvaTableConverter(PvaConverter[Table]):
 
 
 # https://mdavidsaver.github.io/p4p/values.html
+_float_specifiers = {"f", "d"}
+_int_specifiers = {"b", "B", "h", "H", "i", "I", "l", "L"}
+_number_specifiers = _float_specifiers.union(_int_specifiers)
 _datatype_converter_from_typeid: dict[
     tuple[str, str], tuple[type[SignalDatatype], type[PvaConverter]]
 ] = {
@@ -208,7 +230,7 @@ _datatype_converter_from_typeid: dict[
 }
 
 
-def _get_specifier(value: Value):
+def _get_specifier(value: Value) -> str:
     typ = value.type("value").aspy()
     if isinstance(typ, tuple):
         return typ[0]
@@ -258,7 +280,7 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return PvaConverter(int)
+        return PvaIntConverter()
     elif inferred_datatype is str and (enum_cls := get_enum_cls(datatype)):
         # Allow strings to be used as enums until QSRV supports this
         return PvaConverter(str)
@@ -301,7 +323,7 @@ async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
     except asyncio.TimeoutError as exc:
-        logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+        logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 
 
@@ -383,10 +405,15 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
 
             async def async_callback(v):
                 callback(self._make_reading(v))
@@ -397,6 +424,3 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             self.subscription = context().monitor(
                 self.read_pv, async_callback, request=request
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

ophyd_async/epics/core/_util.py

@@ -47,7 +47,7 @@ def get_supported_values(
 
 
 def format_datatype(datatype: Any) -> str:
-    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+    if get_origin(datatype) is np.ndarray and get_args(datatype):
         dtype = get_dtype(datatype)
         return f"Array1D[np.{dtype.name}]"
     elif get_origin(datatype) is Sequence: