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

ophyd_async/epics/motor.py

@@ -63,6 +63,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, prefix + ".EGU")
             self.velocity = epics_signal_rw(float, prefix + ".VELO")
+            self.offset = epics_signal_rw(float, prefix + ".OFF")
 
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback = epics_signal_r(float, prefix + ".RBV")
@@ -125,9 +126,9 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        assert (
-            self._fly_completed_position
-        ), "Motor must be prepared before attempting to kickoff"
+        if not self._fly_completed_position:
+            msg = "Motor must be prepared before attempting to kickoff"
+            raise RuntimeError(msg)
 
         self._fly_status = self.set(
             self._fly_completed_position, timeout=self._fly_timeout
@@ -135,7 +136,9 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        assert self._fly_status, "kickoff not called"
+        if not self._fly_status:
+            msg = "kickoff not called"
+            raise RuntimeError(msg)
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
@@ -155,13 +158,18 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
+
         if timeout is CALCULATE_TIMEOUT:
-            assert velocity > 0, "Motor has zero velocity"
-            timeout = (
-                abs(new_position - old_position) / velocity
-                + 2 * acceleration_time
-                + DEFAULT_TIMEOUT
-            )
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity)
+                    + 2 * acceleration_time
+                    + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
         async for current_position in observe_value(
             self.user_readback, done_status=move_status

ophyd_async/epics/sim/_ioc.py

@@ -0,0 +1,29 @@
+import atexit
+from pathlib import Path
+
+from ophyd_async.epics.testing import TestingIOC
+
+HERE = Path(__file__).absolute().parent
+
+
+def start_ioc_subprocess(prefix: str, num_counters: int):
+    """Start an IOC subprocess with EPICS database for sample stage and sensor
+    with the same pv prefix
+    """
+    ioc = TestingIOC()
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        ioc.add_database(HERE / "mover.db", P=f"{prefix}STAGE:{suffix}:")
+    # Create a multichannel counter with num_counters
+    ioc.add_database(HERE / "multichannelcounter.db", P=f"{prefix}MCC:")
+    for i in range(1, num_counters + 1):
+        ioc.add_database(
+            HERE / "counter.db",
+            P=f"{prefix}MCC:",
+            CHANNEL=str(i),
+            X=f"{prefix}STAGE:X:",
+            Y=f"{prefix}STAGE:Y:",
+        )
+    # Start IOC and register it to be stopped at exit
+    ioc.start()
+    atexit.register(ioc.stop)

ophyd_async/epics/{demo → sim}/_mover.py

@@ -52,13 +52,19 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout == CALCULATE_TIMEOUT:
-            assert velocity > 0, "Mover has zero velocity"
-            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        if timeout is CALCULATE_TIMEOUT:
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity) + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         # Make an Event that will be set on completion, and a Status that will
         # error if not done in time
         done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))  # type: ignore
         # Wait for the value to set, but don't wait for put completion callback
         await self.setpoint.set(new_position, wait=False)
         async for current_position in observe_value(

ophyd_async/epics/testing/__init__.py

@@ -1,24 +1,24 @@
 from ._example_ioc import (
     CA_PVA_RECORDS,
     PVA_RECORDS,
-    ExampleCaDevice,
-    ExampleEnum,
-    ExamplePvaDevice,
-    ExampleTable,
-    connect_example_device,
-    get_example_ioc,
+    EpicsTestCaDevice,
+    EpicsTestEnum,
+    EpicsTestIocAndDevices,
+    EpicsTestPvaDevice,
+    EpicsTestSubsetEnum,
+    EpicsTestTable,
 )
-from ._utils import TestingIOC, generate_random_PV_prefix
+from ._utils import TestingIOC, generate_random_pv_prefix
 
 __all__ = [
     "CA_PVA_RECORDS",
     "PVA_RECORDS",
-    "ExampleCaDevice",
-    "ExampleEnum",
-    "ExamplePvaDevice",
-    "ExampleTable",
-    "connect_example_device",
-    "get_example_ioc",
+    "EpicsTestCaDevice",
+    "EpicsTestEnum",
+    "EpicsTestSubsetEnum",
+    "EpicsTestPvaDevice",
+    "EpicsTestTable",
+    "EpicsTestIocAndDevices",
     "TestingIOC",
-    "generate_random_PV_prefix",
+    "generate_random_pv_prefix",
 ]

ophyd_async/epics/testing/_example_ioc.py

@@ -1,50 +1,49 @@
 from collections.abc import Sequence
 from pathlib import Path
 from typing import Annotated as A
-from typing import Literal
 
 import numpy as np
 
-from ophyd_async.core import (
-    Array1D,
-    SignalRW,
-    StrictEnum,
-    Table,
-)
-from ophyd_async.epics.core import (
-    EpicsDevice,
-    PvSuffix,
-)
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
+from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
-from ._utils import TestingIOC
+from ._utils import TestingIOC, generate_random_pv_prefix
 
-CA_PVA_RECORDS = str(Path(__file__).parent / "test_records.db")
-PVA_RECORDS = str(Path(__file__).parent / "test_records_pva.db")
+CA_PVA_RECORDS = Path(__file__).parent / "test_records.db"
+PVA_RECORDS = Path(__file__).parent / "test_records_pva.db"
 
 
-class ExampleEnum(StrictEnum):
+class EpicsTestEnum(StrictEnum):
     A = "Aaa"
     B = "Bbb"
     C = "Ccc"
 
 
-class ExampleTable(Table):
+class EpicsTestSubsetEnum(SubsetEnum):
+    A = "Aaa"
+    B = "Bbb"
+
+
+class EpicsTestTable(Table):
     bool: Array1D[np.bool_]
     int: Array1D[np.int32]
     float: Array1D[np.float64]
     str: Sequence[str]
-    enum: Sequence[ExampleEnum]
+    enum: Sequence[EpicsTestEnum]
 
 
-class ExampleCaDevice(EpicsDevice):
+class EpicsTestCaDevice(EpicsDevice):
     my_int: A[SignalRW[int], PvSuffix("int")]
     my_float: A[SignalRW[float], PvSuffix("float")]
+    float_prec_0: A[SignalRW[int], PvSuffix("float_prec_0")]
     my_str: A[SignalRW[str], PvSuffix("str")]
     longstr: A[SignalRW[str], PvSuffix("longstr")]
-    longstr2: A[SignalRW[str], PvSuffix("longstr2")]
+    longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
     my_bool: A[SignalRW[bool], PvSuffix("bool")]
-    enum: A[SignalRW[ExampleEnum], PvSuffix("enum")]
-    enum2: A[SignalRW[ExampleEnum], PvSuffix("enum2")]
+    enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
+    enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
+    subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]
     bool_unnamed: A[SignalRW[bool], PvSuffix("bool_unnamed")]
     partialint: A[SignalRW[int], PvSuffix("partialint")]
     lessint: A[SignalRW[int], PvSuffix("lessint")]
@@ -56,52 +55,36 @@ class ExampleCaDevice(EpicsDevice):
     stra: A[SignalRW[Sequence[str]], PvSuffix("stra")]
 
 
-class ExamplePvaDevice(ExampleCaDevice):  # pva can support all signal types that ca can
+class EpicsTestPvaDevice(EpicsTestCaDevice):
+    # pva can support all signal types that ca can
     int8a: A[SignalRW[Array1D[np.int8]], PvSuffix("int8a")]
     uint16a: A[SignalRW[Array1D[np.uint16]], PvSuffix("uint16a")]
     uint32a: A[SignalRW[Array1D[np.uint32]], PvSuffix("uint32a")]
     int64a: A[SignalRW[Array1D[np.int64]], PvSuffix("int64a")]
     uint64a: A[SignalRW[Array1D[np.uint64]], PvSuffix("uint64a")]
-    table: A[SignalRW[ExampleTable], PvSuffix("table")]
-    ntndarray_data: A[SignalRW[Array1D[np.int64]], PvSuffix("ntndarray:data")]
-
-
-async def connect_example_device(
-    ioc: TestingIOC, protocol: Literal["ca", "pva"]
-) -> ExamplePvaDevice | ExampleCaDevice:
-    """Helper function to return a connected example device.
-
-    Parameters
-    ----------
-
-    ioc: TestingIOC
-        TestingIOC configured to provide the records needed for the device
-
-    protocol: Literal["ca", "pva"]
-        The transport protocol of the device
-
-    Returns
-    -------
-    ExamplePvaDevice | ExampleCaDevice
-        a connected EpicsDevice with signals of many EPICS record types
-    """
-    device_cls = ExamplePvaDevice if protocol == "pva" else ExampleCaDevice
-    device = device_cls(f"{protocol}://{ioc.prefix_for(device_cls)}")
-    await device.connect()
-    return device
-
-
-def get_example_ioc() -> TestingIOC:
-    """Get TestingIOC instance with the example databases loaded.
-
-    Returns
-    -------
-    TestingIOC
-        instance with test_records.db loaded for ExampleCaDevice and
-        test_records.db and test_records_pva.db loaded for ExamplePvaDevice.
-    """
-    ioc = TestingIOC()
-    ioc.database_for(PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExampleCaDevice)
-    return ioc
+    table: A[SignalRW[EpicsTestTable], PvSuffix("table")]
+    ntndarray: A[SignalR[np.ndarray], PvSuffix("ntndarray")]
+
+
+class EpicsTestIocAndDevices:
+    def __init__(self):
+        self.prefix = generate_random_pv_prefix()
+        self.ioc = TestingIOC()
+        # Create supporting records and ExampleCaDevice
+        ca_prefix = f"{self.prefix}ca:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=ca_prefix)
+        self.ca_device = EpicsTestCaDevice(f"ca://{ca_prefix}")
+        # Create supporting records and ExamplePvaDevice
+        pva_prefix = f"{self.prefix}pva:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=pva_prefix)
+        self.ioc.add_database(PVA_RECORDS, device=pva_prefix)
+        self.pva_device = EpicsTestPvaDevice(f"pva://{pva_prefix}")
+
+    def get_device(self, protocol: str) -> EpicsTestCaDevice | EpicsTestPvaDevice:
+        return getattr(self, f"{protocol}_device")
+
+    def get_signal(self, protocol: str, name: str) -> SignalRW:
+        return getattr(self.get_device(protocol), name)
+
+    def get_pv(self, protocol: str, name: str) -> str:
+        return f"{protocol}://{self.prefix}{protocol}:{name}"

ophyd_async/epics/testing/_utils.py

@@ -5,50 +5,28 @@ import sys
 import time
 from pathlib import Path
 
-from aioca import purge_channel_caches
 
-from ophyd_async.core import Device
-
-
-def generate_random_PV_prefix() -> str:
+def generate_random_pv_prefix() -> str:
     return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
 
 
 class TestingIOC:
-    _dbs: dict[type[Device], list[Path]] = {}
-    _prefixes: dict[type[Device], str] = {}
-
-    @classmethod
-    def with_database(cls, db: Path | str):  # use as a decorator
-        def inner(device_cls: type[Device]):
-            cls.database_for(db, device_cls)
-            return device_cls
-
-        return inner
-
-    @classmethod
-    def database_for(cls, db, device_cls):
-        path = Path(db)
-        if not path.is_file():
-            raise OSError(f"{path} is not a file.")
-        if device_cls not in cls._dbs:
-            cls._dbs[device_cls] = []
-        cls._dbs[device_cls].append(path)
+    def __init__(self):
+        self._db_macros: list[tuple[Path, dict[str, str]]] = []
+        self.output = ""
 
-    def prefix_for(self, device_cls):
-        # generate random prefix, return existing if already generated
-        return self._prefixes.setdefault(device_cls, generate_random_PV_prefix())
+    def add_database(self, db: Path | str, /, **macros: str):
+        self._db_macros.append((Path(db), macros))
 
-    def start_ioc(self):
+    def start(self):
         ioc_args = [
             sys.executable,
             "-m",
             "epicscorelibs.ioc",
         ]
-        for device_cls, dbs in self._dbs.items():
-            prefix = self.prefix_for(device_cls)
-            for db in dbs:
-                ioc_args += ["-m", f"device={prefix}", "-d", str(db)]
+        for db, macros in self._db_macros:
+            macro_str = ",".join(f"{k}={v}" for k, v in macros.items())
+            ioc_args += ["-m", macro_str, "-d", str(db)]
         self._process = subprocess.Popen(
             ioc_args,
             stdin=subprocess.PIPE,
@@ -56,23 +34,17 @@ class TestingIOC:
             stderr=subprocess.STDOUT,
             universal_newlines=True,
         )
+        assert self._process.stdout  # noqa: S101 # this is to make Pylance happy
         start_time = time.monotonic()
-        while "iocRun: All initialization complete" not in (
-            self._process.stdout.readline().strip()  # type: ignore
-        ):
+        while "iocRun: All initialization complete" not in self.output:
             if time.monotonic() - start_time > 10:
-                try:
-                    print(self._process.communicate("exit()")[0])
-                except ValueError:
-                    # Someone else already called communicate
-                    pass
-                raise TimeoutError("IOC did not start in time")
+                self.stop()
+                raise TimeoutError(f"IOC did not start in time:\n{self.output}")
+            self.output += self._process.stdout.readline()
 
-    def stop_ioc(self):
-        # close backend caches before the event loop
-        purge_channel_caches()
+    def stop(self):
         try:
-            print(self._process.communicate("exit()")[0])
+            self.output += self._process.communicate("exit()")[0]
         except ValueError:
             # Someone else already called communicate
             pass

ophyd_async/epics/testing/test_records.db

@@ -96,6 +96,14 @@ record(mbbo, "$(device)enum2") {
   field(PINI, "YES")
 }
 
+record(mbbo, "$(device)subset_enum") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")

ophyd_async/fastcs/panda/__init__.py

@@ -23,7 +23,6 @@ from ._trigger import (
     StaticPcompTriggerLogic,
     StaticSeqTableTriggerLogic,
 )
-from ._utils import phase_sorter
 from ._writer import PandaHDFWriter
 
 __all__ = [
@@ -47,5 +46,4 @@ __all__ = [
     "SeqTableInfo",
     "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
-    "phase_sorter",
 ]

ophyd_async/fastcs/panda/_control.py

@@ -18,10 +18,15 @@ class PandaPcapController(DetectorController):
         return 0.000000008
 
     async def prepare(self, trigger_info: TriggerInfo):
-        assert trigger_info.trigger in (
+        if trigger_info.trigger not in (
             DetectorTrigger.CONSTANT_GATE,
             DetectorTrigger.VARIABLE_GATE,
-        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        ):
+            msg = (
+                "Only constant_gate and variable_gate triggering is supported on "
+                "the PandA",
+            )
+            raise TypeError(msg)
 
     async def arm(self):
         self._arm_status = self.pcap.arm.set(True)

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -12,7 +12,9 @@ from ._writer import PandaHDFWriter
 MINIMUM_PANDA_IOC = "0.11.4"
 
 
-class HDFPanda(CommonPandaBlocks, StandardDetector):
+class HDFPanda(
+    CommonPandaBlocks, StandardDetector[PandaPcapController, PandaHDFWriter]
+):
     def __init__(
         self,
         prefix: str,

ophyd_async/fastcs/panda/_table.py

@@ -83,5 +83,8 @@ class SeqTable(Table):
         """
 
         first_length = len(self)
-        assert first_length <= 4096, f"Length {first_length} is too long"
+        max_length = 4096
+        if first_length > max_length:
+            msg = f"Length {first_length} is too long"
+            raise ValueError(msg)
         return self

ophyd_async/plan_stubs/__init__.py

@@ -5,6 +5,14 @@ from ._fly import (
     time_resolved_fly_and_collect_with_static_seq_table,
 )
 from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
+from ._panda import apply_panda_settings
+from ._settings import (
+    apply_settings,
+    apply_settings_if_different,
+    get_current_settings,
+    retrieve_settings,
+    store_settings,
+)
 
 __all__ = [
     "fly_and_collect",
@@ -13,4 +21,10 @@ __all__ = [
     "ensure_connected",
     "setup_ndattributes",
     "setup_ndstats_sum",
+    "apply_panda_settings",
+    "apply_settings",
+    "apply_settings_if_different",
+    "get_current_settings",
+    "retrieve_settings",
+    "store_settings",
 ]

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,10 +1,11 @@
-from collections.abc import Awaitable
-
-import bluesky.plan_stubs as bps
+from bluesky.utils import plan
 
 from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
+from ._wait_for_awaitable import wait_for_awaitable
+
 
+@plan
 def ensure_connected(
     *devices: Device,
     mock: bool | LazyMock = False,
@@ -17,17 +18,10 @@ def ensure_connected(
     }
     if non_unique:
         raise ValueError(f"Devices do not have unique names {non_unique}")
-
-    def connect_devices() -> Awaitable[None]:
-        coros = {
-            device.name: device.connect(
-                mock=mock, timeout=timeout, force_reconnect=force_reconnect
-            )
-            for device in devices
-        }
-        return wait_for_connection(**coros)
-
-    (connect_task,) = yield from bps.wait_for([connect_devices])
-
-    if connect_task and connect_task.exception() is not None:
-        raise connect_task.exception()
+    coros = {
+        device.name: device.connect(
+            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        )
+        for device in devices
+    }
+    yield from wait_for_awaitable(wait_for_connection(**coros))

ophyd_async/plan_stubs/_fly.py

@@ -58,7 +58,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     if not detectors:
         raise ValueError("No detectors provided. There must be at least one.")
 
-    deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
+    deadtime = max(det._controller.get_deadtime(exposure) for det in detectors)  # noqa: SLF001
 
     trigger_info = TriggerInfo(
         number_of_triggers=number_of_frames * repeats,

ophyd_async/plan_stubs/_nd_attributes.py

@@ -50,11 +50,13 @@ def setup_ndattributes(
 
 
 def setup_ndstats_sum(detector: Device):
-    hdf = getattr(detector, "hdf", None)
-    assert isinstance(hdf, NDFileHDFIO), (
-        f"Expected {detector.name} to have 'hdf' attribute that is an NDFilHDFIO, "
-        f"got {hdf}"
-    )
+    hdf = getattr(detector, "fileio", None)
+    if not isinstance(hdf, NDFileHDFIO):
+        msg = (
+            f"Expected {detector.name} to have 'fileio' attribute that is an "
+            f"NDFileHDFIO, got {hdf}"
+        )
+        raise TypeError(msg)
     yield from (
         setup_ndattributes(
             hdf,

ophyd_async/plan_stubs/_panda.py

@@ -0,0 +1,13 @@
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import Settings
+from ophyd_async.fastcs import panda
+
+from ._settings import apply_settings
+
+
+@plan
+def apply_panda_settings(settings: Settings[panda.HDFPanda]) -> MsgGenerator[None]:
+    units, others = settings.partition(lambda signal: signal.name.endswith("_units"))
+    yield from apply_settings(units)
+    yield from apply_settings(others)