ophyd-async 0.5.2__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from ophyd_async.core import PathProvider, SignalR, StandardDetector
 from ophyd_async.epics import adcore
@@ -12,14 +12,15 @@ class SimDetector(StandardDetector):
 
     def __init__(
         self,
-        drv: adcore.ADBaseIO,
-        hdf: adcore.NDFileHDFIO,
+        prefix: str,
         path_provider: PathProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = drv
-        self.hdf = hdf
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             SimController(self.drv),
@@ -29,6 +30,6 @@ class SimDetector(StandardDetector):
                 lambda: self.name,
                 adcore.ADBaseDatasetDescriber(self.drv),
             ),
-            config_sigs=config_sigs,
+            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
             name=name,
         )

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -1,45 +1,50 @@
 import asyncio
-from typing import Optional, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
 )
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 
-class SimController(DetectorControl):
+class SimController(DetectorController):
     def __init__(
         self,
         driver: adcore.ADBaseIO,
-        good_states: Set[adcore.DetectorState] = set(adcore.DEFAULT_GOOD_STATES),
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
+        self.frame_timeout: float
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.002
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         assert (
-            trigger == DetectorTrigger.internal
+            trigger_info.trigger == DetectorTrigger.internal
         ), "fly scanning (i.e. external triggering) is not supported for this device"
-        frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        self.frame_timeout = (
+            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        )
         await asyncio.gather(
-            self.driver.num_images.set(num),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
             self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
-        return await adcore.start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states, timeout=frame_timeout
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=self.frame_timeout
         )
 
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,7 +1,8 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorController, DetectorTrigger
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
@@ -21,38 +22,42 @@ EXPOSE_OUT_MODE = {
 }
 
 
-class VimbaController(DetectorControl):
+class VimbaController(DetectorController):
     def __init__(
         self,
         driver: VimbaDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
-            self._drv.num_images.set(num),
+            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),
         )
-        if exposure is not None and trigger not in [
+        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(exposure)
-        if trigger != DetectorTrigger.internal:
+            await self._drv.acquire_time.set(trigger_info.livetime)
+        if trigger_info.trigger != DetectorTrigger.internal:
             self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
             self._drv.trigger_source.set(VimbaTriggerSource.freerun)
-        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
+
+    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)

ophyd_async/epics/demo/_mover.py

@@ -4,10 +4,10 @@ import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     Device,
     HintedSignal,
@@ -44,9 +44,8 @@ class Mover(StandardReadable, Movable, Stoppable):
         self.readback.set_name(name)
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         old_position, units, precision, velocity = await asyncio.gather(
             self.setpoint.get_value(),
@@ -54,7 +53,7 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout == CALCULATE_TIMEOUT:
             assert velocity > 0, "Mover has zero velocity"
             timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
         # Make an Event that will be set on completion, and a Status that will

ophyd_async/epics/demo/sensor.db

@@ -17,4 +17,3 @@ record(calc, "$(P)Value") {
     field(EGU,  "$(EGU=cts/s)")
     field(PREC, "$(PREC=3)")
 }
-

ophyd_async/epics/eiger/_eiger.py

@@ -38,6 +38,6 @@ class EigerDetector(StandardDetector):
         )
 
     @AsyncStatus.wrap
-    async def prepare(self, value: EigerTriggerInfo) -> None:
+    async def prepare(self, value: EigerTriggerInfo) -> None:  # type: ignore
         await self._controller.set_energy(value.energy_ev)
         await super().prepare(value)

ophyd_async/epics/eiger/_eiger_controller.py

@@ -1,13 +1,12 @@
 import asyncio
-from typing import Optional
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     set_and_wait_for_other_value,
 )
+from ophyd_async.core._detector import TriggerInfo
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 
@@ -19,14 +18,14 @@ EIGER_TRIGGER_MODE_MAP = {
 }
 
 
-class EigerController(DetectorControl):
+class EigerController(DetectorController):
     def __init__(
         self,
         driver: EigerDriverIO,
     ) -> None:
         self._drv = driver
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
         return 0.0001
 
@@ -37,30 +36,31 @@ class EigerController(DetectorControl):
         if abs(current_energy - energy) > tolerance:
             await self._drv.photon_energy.set(energy)
 
-    @AsyncStatus.wrap
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ):
+    async def prepare(self, trigger_info: TriggerInfo):
         coros = [
-            self._drv.trigger_mode.set(EIGER_TRIGGER_MODE_MAP[trigger].value),
-            self._drv.num_images.set(num),
+            self._drv.trigger_mode.set(
+                EIGER_TRIGGER_MODE_MAP[trigger_info.trigger].value
+            ),
+            self._drv.num_images.set(trigger_info.total_number_of_triggers),
         ]
-        if exposure is not None:
+        if trigger_info.livetime is not None:
             coros.extend(
                 [
-                    self._drv.acquire_time.set(exposure),
-                    self._drv.acquire_period.set(exposure),
+                    self._drv.acquire_time.set(trigger_info.livetime),
+                    self._drv.acquire_period.set(trigger_info.livetime),
                 ]
             )
         await asyncio.gather(*coros)
 
+    async def arm(self):
         # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
-        await set_and_wait_for_other_value(
+        self._arm_status = set_and_wait_for_other_value(
             self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
         )
 
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
     async def disarm(self):
         await self._drv.disarm.set(1)

ophyd_async/epics/eiger/_odin_io.py

@@ -1,9 +1,9 @@
 import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
 from enum import Enum
-from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import StreamAsset
-from event_model.documents.event_descriptor import DataKey
+from event_model import DataKey
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -77,7 +77,7 @@ class OdinWriter(DetectorWriter):
         self._name_provider = name_provider
         super().__init__()
 
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         info = self._path_provider(device_name=self._name_provider())
 
         await asyncio.gather(
@@ -93,7 +93,7 @@ class OdinWriter(DetectorWriter):
 
         return await self._describe()
 
-    async def _describe(self) -> Dict[str, DataKey]:
+    async def _describe(self) -> dict[str, DataKey]:
         data_shape = await asyncio.gather(
             self._drv.image_height.get_value(), self._drv.image_width.get_value()
         )
@@ -103,7 +103,8 @@ class OdinWriter(DetectorWriter):
                 source=self._drv.file_name.source,
                 shape=data_shape,
                 dtype="array",
-                dtype_numpy="<u2",  # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                dtype_numpy="<u2",  # type: ignore
                 external="STREAM:",
             )
         }

ophyd_async/epics/motor.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Optional
 
 from bluesky.protocols import (
     Flyable,
@@ -11,10 +10,10 @@ from bluesky.protocols import (
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     HintedSignal,
     StandardReadable,
@@ -54,7 +53,7 @@ class FlyMotorInfo(BaseModel):
 
     #: Maximum time for the complete motor move, including run up and run down.
     #: Defaults to `time_for_move` + run up and run down times + 10s.
-    timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
+    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
 
 
 class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
@@ -83,13 +82,13 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self._set_success = True
 
         # end_position of a fly move, with run_up_distance added on.
-        self._fly_completed_position: Optional[float] = None
+        self._fly_completed_position: float | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
-        self._fly_status: Optional[WatchableAsyncStatus] = None
+        self._fly_status: WatchableAsyncStatus | None = None
 
         # Set during prepare
-        self._fly_timeout: Optional[CalculatableTimeout] = CalculateTimeout
+        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
 
         super().__init__(name=name)
 
@@ -138,9 +137,8 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         (
             old_position,
@@ -155,7 +153,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout is CALCULATE_TIMEOUT:
             assert velocity > 0, "Motor has zero velocity"
             timeout = (
                 abs(new_position - old_position) / velocity

ophyd_async/epics/pvi/_pvi.py

@@ -1,15 +1,11 @@
 import re
+import types
+from collections.abc import Callable
 from dataclasses import dataclass
 from inspect import isclass
 from typing import (
     Any,
-    Callable,
-    Dict,
-    FrozenSet,
     Literal,
-    Optional,
-    Tuple,
-    Type,
     Union,
     get_args,
     get_origin,
@@ -32,23 +28,24 @@ from ophyd_async.epics.signal import (
     epics_signal_x,
 )
 
-Access = FrozenSet[
-    Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
+Access = frozenset[
+    Literal["r"] | Literal["w"] | Literal["rw"] | Literal["x"] | Literal["d"]
 ]
 
 
-def _strip_number_from_string(string: str) -> Tuple[str, Optional[int]]:
+def _strip_number_from_string(string: str) -> tuple[str, int | None]:
     match = re.match(r"(.*?)(\d*)$", string)
     assert match
 
     name = match.group(1)
     number = match.group(2) or None
-    if number:
-        number = int(number)
-    return name, number
+    if number is None:
+        return name, None
+    else:
+        return name, int(number)
 
 
-def _split_subscript(tp: T) -> Union[Tuple[Any, Tuple[Any]], Tuple[T, None]]:
+def _split_subscript(tp: T) -> tuple[Any, tuple[Any]] | tuple[T, None]:
     """Split a subscripted type into the its origin and args.
 
     If `tp` is not a subscripted type, then just return the type and None as args.
@@ -60,8 +57,8 @@ def _split_subscript(tp: T) -> Union[Tuple[Any, Tuple[Any]], Tuple[T, None]]:
     return tp, None
 
 
-def _strip_union(field: Union[Union[T], T]) -> Tuple[T, bool]:
-    if get_origin(field) is Union:
+def _strip_union(field: T | T) -> tuple[T, bool]:
+    if get_origin(field) in [Union, types.UnionType]:
         args = get_args(field)
         is_optional = type(None) in args
         for arg in args:
@@ -70,7 +67,7 @@ def _strip_union(field: Union[Union[T], T]) -> Tuple[T, bool]:
     return field, False
 
 
-def _strip_device_vector(field: Union[Type[Device]]) -> Tuple[bool, Type[Device]]:
+def _strip_device_vector(field: type[Device]) -> tuple[bool, type[Device]]:
     if get_origin(field) is DeviceVector:
         return True, get_args(field)[0]
     return False, field
@@ -83,13 +80,13 @@ class _PVIEntry:
     This could either be a signal or a sub-table.
     """
 
-    sub_entries: Dict[str, Union[Dict[int, "_PVIEntry"], "_PVIEntry"]]
-    pvi_pv: Optional[str] = None
-    device: Optional[Device] = None
-    common_device_type: Optional[Type[Device]] = None
+    sub_entries: dict[str, Union[dict[int, "_PVIEntry"], "_PVIEntry"]]
+    pvi_pv: str | None = None
+    device: Device | None = None
+    common_device_type: type[Device] | None = None
 
 
-def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
+def _verify_common_blocks(entry: _PVIEntry, common_device: type[Device]):
     if not entry.sub_entries:
         return
     common_sub_devices = get_type_hints(common_device)
@@ -107,12 +104,12 @@ def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
                 _verify_common_blocks(sub_sub_entry, sub_device)  # type: ignore
         else:
             _verify_common_blocks(
-                entry.sub_entries[sub_name],
+                entry.sub_entries[sub_name],  # type: ignore
                 sub_device,  # type: ignore
             )
 
 
-_pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
+_pvi_mapping: dict[frozenset[str], Callable[..., Signal]] = {
     frozenset({"r", "w"}): lambda dtype, read_pv, write_pv: epics_signal_rw(
         dtype, "pva://" + read_pv, "pva://" + write_pv
     ),
@@ -129,8 +126,8 @@ _pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
 
 def _parse_type(
     is_pvi_table: bool,
-    number_suffix: Optional[int],
-    common_device_type: Optional[Type[Device]],
+    number_suffix: int | None,
+    common_device_type: type[Device] | None,
 ):
     if common_device_type:
         # pre-defined type
@@ -159,7 +156,7 @@ def _parse_type(
     return is_device_vector, is_signal, signal_dtype, device_cls
 
 
-def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+def _mock_common_blocks(device: Device, stripped_type: type | None = None):
     device_t = stripped_type or type(device)
     sub_devices = (
         (field, field_type)
@@ -173,11 +170,10 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
         device_cls, device_args = _split_subscript(device_cls)
         assert issubclass(device_cls, Device)
 
-        is_signal = issubclass(device_cls, Signal)
         signal_dtype = device_args[0] if device_args is not None else None
 
         if is_device_vector:
-            if is_signal:
+            if issubclass(device_cls, Signal):
                 sub_device_1 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
@@ -198,7 +194,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
             for value in sub_device.values():
                 value.parent = sub_device
         else:
-            if is_signal:
+            if issubclass(device_cls, Signal):
                 sub_device = device_cls(SoftSignalBackend(signal_dtype))
             else:
                 sub_device = getattr(device, device_name, device_cls())
@@ -271,7 +267,8 @@ def _set_device_attributes(entry: _PVIEntry):
                 # Set the device vector entry to have the device vector as a parent
                 device_vector_sub_entry.device.parent = sub_device  # type: ignore
         else:
-            sub_device = sub_entry.device  # type: ignore
+            sub_device = sub_entry.device
+            assert sub_device, f"Device of {sub_entry} is None"
             if sub_entry.pvi_pv:
                 _set_device_attributes(sub_entry)
 
@@ -308,8 +305,8 @@ async def fill_pvi_entries(
 
 def create_children_from_annotations(
     device: Device,
-    included_optional_fields: Tuple[str, ...] = (),
-    device_vectors: Optional[Dict[str, int]] = None,
+    included_optional_fields: tuple[str, ...] = (),
+    device_vectors: dict[str, int] | None = None,
 ):
     """For intializing blocks at __init__ of ``device``."""
     for name, device_type in get_type_hints(type(device)).items():
@@ -328,7 +325,7 @@ def create_children_from_annotations(
 
         if is_device_vector:
             n_device_vector = DeviceVector(
-                {i: device_type() for i in range(1, device_vectors[name] + 1)}
+                {i: device_type() for i in range(1, device_vectors[name] + 1)}  # type: ignore
             )
             setattr(device, name, n_device_vector)
             for sub_device in n_device_vector.values():