ophyd-async 0.7.0__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,10 +1,9 @@
-from enum import Enum
-
+from ophyd_async.core import StrictEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
-class VimbaPixelFormat(str, Enum):
+class VimbaPixelFormat(StrictEnum):
     internal = "Mono8"
     ext_enable = "Mono12"
     ext_trigger = "Ext. Trigger"
@@ -12,7 +11,7 @@ class VimbaPixelFormat(str, Enum):
     alignment = "Alignment"
 
 
-class VimbaConvertFormat(str, Enum):
+class VimbaConvertFormat(StrictEnum):
     none = "None"
     mono8 = "Mono8"
     mono16 = "Mono16"
@@ -20,7 +19,7 @@ class VimbaConvertFormat(str, Enum):
     rgb16 = "RGB16"
 
 
-class VimbaTriggerSource(str, Enum):
+class VimbaTriggerSource(StrictEnum):
     freerun = "Freerun"
     line1 = "Line1"
     line2 = "Line2"
@@ -30,17 +29,17 @@ class VimbaTriggerSource(str, Enum):
     action1 = "Action1"
 
 
-class VimbaOverlap(str, Enum):
+class VimbaOverlap(StrictEnum):
     off = "Off"
     prev_frame = "PreviousFrame"
 
 
-class VimbaOnOff(str, Enum):
+class VimbaOnOff(StrictEnum):
     on = "On"
     off = "Off"
 
 
-class VimbaExposeOutMode(str, Enum):
+class VimbaExposeOutMode(StrictEnum):
     timed = "Timed"  # Use ExposureTime PV
     trigger_width = "TriggerWidth"  # Expose for length of high signal
 

ophyd_async/epics/demo/_sensor.py

@@ -1,10 +1,14 @@
-from enum import Enum
-
-from ophyd_async.core import ConfigSignal, DeviceVector, HintedSignal, StandardReadable
+from ophyd_async.core import (
+    ConfigSignal,
+    DeviceVector,
+    HintedSignal,
+    StandardReadable,
+    StrictEnum,
+)
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
-class EnergyMode(str, Enum):
+class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode

ophyd_async/epics/eiger/_eiger.py

@@ -1,7 +1,6 @@
 from pydantic import Field
 
-from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector, TriggerInfo
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO

ophyd_async/epics/eiger/_eiger_controller.py

@@ -4,9 +4,9 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorController,
     DetectorTrigger,
+    TriggerInfo,
     set_and_wait_for_other_value,
 )
-from ophyd_async.core._detector import TriggerInfo
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 

ophyd_async/epics/eiger/_eiger_io.py

@@ -1,10 +1,8 @@
-from enum import Enum
-
-from ophyd_async.core import Device
+from ophyd_async.core import Device, StrictEnum
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
 
-class EigerTriggerMode(str, Enum):
+class EigerTriggerMode(StrictEnum):
     internal = "ints"
     edge = "exts"
     gate = "exte"

ophyd_async/epics/eiger/_odin_io.py

@@ -1,6 +1,5 @@
 import asyncio
 from collections.abc import AsyncGenerator, AsyncIterator
-from enum import Enum
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
@@ -12,6 +11,7 @@ from ophyd_async.core import (
     DeviceVector,
     NameProvider,
     PathProvider,
+    StrictEnum,
     observe_value,
     set_and_wait_for_value,
 )
@@ -22,7 +22,7 @@ from ophyd_async.epics.signal import (
 )
 
 
-class Writing(str, Enum):
+class Writing(StrictEnum):
     ON = "ON"
     OFF = "OFF"
 
@@ -101,10 +101,10 @@ class OdinWriter(DetectorWriter):
         return {
             "data": DataKey(
                 source=self._drv.file_name.source,
-                shape=data_shape,
+                shape=list(data_shape),
                 dtype="array",
                 # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
-                dtype_numpy="<u2",  # type: ignore
+                dtype_numpy="<u2",
                 external="STREAM:",
             )
         }

ophyd_async/epics/pvi/__init__.py

@@ -1,3 +1,3 @@
-from ._pvi import create_children_from_annotations, fill_pvi_entries
+from ._pvi import PviDeviceConnector
 
-__all__ = ["fill_pvi_entries", "create_children_from_annotations"]
+__all__ = ["PviDeviceConnector"]

ophyd_async/epics/pvi/_pvi.py

@@ -1,338 +1,73 @@
-import re
-import types
-from collections.abc import Callable
-from dataclasses import dataclass
-from inspect import isclass
-from typing import (
-    Any,
-    Literal,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
+from __future__ import annotations
+
+from unittest.mock import Mock
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     Device,
-    DeviceVector,
+    DeviceConnector,
+    DeviceFiller,
     Signal,
-    SoftSignalBackend,
-    T,
+    SignalR,
+    SignalRW,
+    SignalX,
 )
 from ophyd_async.epics.signal import (
     PvaSignalBackend,
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_w,
-    epics_signal_x,
+    pvget_with_timeout,
 )
 
-Access = frozenset[
-    Literal["r"] | Literal["w"] | Literal["rw"] | Literal["x"] | Literal["d"]
-]
-
-
-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 is None:
-        return name, None
-    else:
-        return name, int(number)
-
-
-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.
-
-    """
-    if get_origin(tp) is not None:
-        return get_origin(tp), get_args(tp)
-
-    return tp, None
-
-
-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:
-            if arg is not type(None):
-                return arg, is_optional
-    return field, False
-
-
-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
-
 
-@dataclass
-class _PVIEntry:
-    """
-    A dataclass to represent a single entry in the PVI table.
-    This could either be a signal or a sub-table.
-    """
+def _get_signal_details(entry: dict[str, str]) -> tuple[type[Signal], str, str]:
+    match entry:
+        case {"r": read_pv}:
+            return SignalR, read_pv, read_pv
+        case {"r": read_pv, "w": write_pv}:
+            return SignalRW, read_pv, write_pv
+        case {"rw": read_write_pv}:
+            return SignalRW, read_write_pv, read_write_pv
+        case {"x": execute_pv}:
+            return SignalX, execute_pv, execute_pv
+        case _:
+            raise TypeError(f"Can't process entry {entry}")
 
-    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
 
+class PviDeviceConnector(DeviceConnector):
+    def __init__(self, pvi_pv: str = "") -> None:
+        self.pvi_pv = pvi_pv
 
-def _verify_common_blocks(entry: _PVIEntry, common_device: type[Device]):
-    if not entry.sub_entries:
-        return
-    common_sub_devices = get_type_hints(common_device)
-    for sub_name, sub_device in common_sub_devices.items():
-        if sub_name.startswith("_") or sub_name == "parent":
-            continue
-        assert entry.sub_entries
-        device_t, is_optional = _strip_union(sub_device)
-        if sub_name not in entry.sub_entries and not is_optional:
-            raise RuntimeError(
-                f"sub device `{sub_name}:{type(sub_device)}` " "was not provided by pvi"
-            )
-        if isinstance(entry.sub_entries[sub_name], dict):
-            for sub_sub_entry in entry.sub_entries[sub_name].values():  # type: ignore
-                _verify_common_blocks(sub_sub_entry, sub_device)  # type: ignore
-        else:
-            _verify_common_blocks(
-                entry.sub_entries[sub_name],  # type: ignore
-                sub_device,  # type: ignore
-            )
-
-
-_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
-    ),
-    frozenset({"rw"}): lambda dtype, read_write_pv: epics_signal_rw(
-        dtype, "pva://" + read_write_pv, write_pv="pva://" + read_write_pv
-    ),
-    frozenset({"r"}): lambda dtype, read_pv: epics_signal_r(dtype, "pva://" + read_pv),
-    frozenset({"w"}): lambda dtype, write_pv: epics_signal_w(
-        dtype, "pva://" + write_pv
-    ),
-    frozenset({"x"}): lambda _, write_pv: epics_signal_x("pva://" + write_pv),
-}
-
-
-def _parse_type(
-    is_pvi_table: bool,
-    number_suffix: int | None,
-    common_device_type: type[Device] | None,
-):
-    if common_device_type:
-        # pre-defined type
-        device_cls, _ = _strip_union(common_device_type)
-        is_device_vector, device_cls = _strip_device_vector(device_cls)
-        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
-
-    elif is_pvi_table:
-        # is a block, we can make it a DeviceVector if it ends in a number
-        is_device_vector = number_suffix is not None
-        is_signal = False
-        signal_dtype = None
-        device_cls = Device
-    else:
-        # is a signal, signals aren't stored in DeviceVectors unless
-        # they're defined as such in the common_device_type
-        is_device_vector = False
-        is_signal = True
-        signal_dtype = None
-        device_cls = Signal
-
-    return is_device_vector, is_signal, signal_dtype, device_cls
-
-
-def _mock_common_blocks(device: Device, stripped_type: type | None = None):
-    device_t = stripped_type or type(device)
-    sub_devices = (
-        (field, field_type)
-        for field, field_type in get_type_hints(device_t).items()
-        if not field.startswith("_") and field != "parent"
-    )
-
-    for device_name, device_cls in sub_devices:
-        device_cls, _ = _strip_union(device_cls)
-        is_device_vector, device_cls = _strip_device_vector(device_cls)
-        device_cls, device_args = _split_subscript(device_cls)
-        assert issubclass(device_cls, Device)
-
-        signal_dtype = device_args[0] if device_args is not None else None
-
-        if is_device_vector:
-            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})
-            else:
-                if hasattr(device, device_name):
-                    sub_device = getattr(device, device_name)
-                else:
-                    sub_device = DeviceVector(
-                        {
-                            1: device_cls(),
-                            2: device_cls(),
-                        }
-                    )
-
-                for sub_device_in_vector in sub_device.values():
-                    _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
-
-            for value in sub_device.values():
-                value.parent = sub_device
-        else:
-            if issubclass(device_cls, Signal):
-                sub_device = device_cls(SoftSignalBackend(signal_dtype))
-            else:
-                sub_device = getattr(device, device_name, device_cls())
-                _mock_common_blocks(sub_device, stripped_type=device_cls)
-
-        setattr(device, device_name, sub_device)
-        sub_device.parent = device
-
-
-async def _get_pvi_entries(entry: _PVIEntry, timeout=DEFAULT_TIMEOUT):
-    if not entry.pvi_pv or not entry.pvi_pv.endswith(":PVI"):
-        raise RuntimeError("Top level entry must be a pvi table")
-
-    pvi_table_signal_backend: PvaSignalBackend = PvaSignalBackend(
-        None, entry.pvi_pv, entry.pvi_pv
-    )
-    await pvi_table_signal_backend.connect(
-        timeout=timeout
-    )  # create table signal backend
-
-    pva_table = (await pvi_table_signal_backend.get_value())["pvi"]
-    common_device_type_hints = (
-        get_type_hints(entry.common_device_type) if entry.common_device_type else {}
-    )
-
-    for sub_name, pva_entries in pva_table.items():
-        pvs = list(pva_entries.values())
-        is_pvi_table = len(pvs) == 1 and pvs[0].endswith(":PVI")
-        sub_name_split, sub_number_split = _strip_number_from_string(sub_name)
-        is_device_vector, is_signal, signal_dtype, device_type = _parse_type(
-            is_pvi_table,
-            sub_number_split,
-            common_device_type_hints.get(sub_name_split),
-        )
-        if is_signal:
-            device = _pvi_mapping[frozenset(pva_entries.keys())](signal_dtype, *pvs)
-        else:
-            device = getattr(entry.device, sub_name, device_type())
-
-        sub_entry = _PVIEntry(
-            device=device, common_device_type=device_type, sub_entries={}
-        )
-
-        if is_device_vector:
-            # If device vector then we store sub_name -> {sub_number -> sub_entry}
-            # and aggregate into `DeviceVector` in `_set_device_attributes`
-            sub_number_split = 1 if sub_number_split is None else sub_number_split
-            if sub_name_split not in entry.sub_entries:
-                entry.sub_entries[sub_name_split] = {}
-            entry.sub_entries[sub_name_split][sub_number_split] = sub_entry  # type: ignore
-        else:
-            entry.sub_entries[sub_name] = sub_entry
-
-        if is_pvi_table:
-            sub_entry.pvi_pv = pvs[0]
-            await _get_pvi_entries(sub_entry)
-
-    if entry.common_device_type:
-        _verify_common_blocks(entry, entry.common_device_type)
-
-
-def _set_device_attributes(entry: _PVIEntry):
-    for sub_name, sub_entry in entry.sub_entries.items():
-        if isinstance(sub_entry, dict):
-            sub_device = DeviceVector()  # type: ignore
-            for key, device_vector_sub_entry in sub_entry.items():
-                sub_device[key] = device_vector_sub_entry.device
-                if device_vector_sub_entry.pvi_pv:
-                    _set_device_attributes(device_vector_sub_entry)
-                # 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
-            assert sub_device, f"Device of {sub_entry} is None"
-            if sub_entry.pvi_pv:
-                _set_device_attributes(sub_entry)
-
-        sub_device.parent = entry.device
-        setattr(entry.device, sub_name, sub_device)
-
-
-async def fill_pvi_entries(
-    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, mock=False
-):
-    """
-    Fills a ``device`` with signals from a the ``root_pvi:PVI`` table.
-
-    If the device names match with parent devices of ``device`` then types are used.
-    """
-    if mock:
-        # set up mock signals for the common annotations
-        _mock_common_blocks(device)
-    else:
-        # check the pvi table for devices and fill the device with them
-        root_entry = _PVIEntry(
-            pvi_pv=root_pv,
+    def create_children_from_annotations(self, device: Device):
+        self._filler = DeviceFiller(
             device=device,
-            common_device_type=type(device),
-            sub_entries={},
+            signal_backend_factory=PvaSignalBackend,
+            device_connector_factory=PviDeviceConnector,
         )
-        await _get_pvi_entries(root_entry, timeout=timeout)
-        _set_device_attributes(root_entry)
-
-    # We call set name now the parent field has been set in all of the
-    # introspect-initialized devices. This will recursively set the names.
-    device.set_name(device.name)
-
-
-def create_children_from_annotations(
-    device: Device,
-    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():
-        if name in ("_name", "parent"):
-            continue
-        device_type, is_optional = _strip_union(device_type)
-        if is_optional and name not in included_optional_fields:
-            continue
-        is_device_vector, device_type = _strip_device_vector(device_type)
-        if (
-            (is_device_vector and (not device_vectors or name not in device_vectors))
-            or ((origin := get_origin(device_type)) and issubclass(origin, Signal))
-            or (isclass(device_type) and issubclass(device_type, Signal))
-        ):
-            continue
 
-        if is_device_vector:
-            n_device_vector = DeviceVector(
-                {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():
-                create_children_from_annotations(
-                    sub_device, device_vectors=device_vectors
-                )
+    async def connect(
+        self, device: Device, mock: bool | Mock, timeout: float, force_reconnect: bool
+    ) -> None:
+        if mock:
+            # Make 2 entries for each DeviceVector
+            self._filler.make_soft_device_vector_entries(2)
         else:
-            sub_device = device_type()
-            setattr(device, name, sub_device)
-            create_children_from_annotations(sub_device, device_vectors=device_vectors)
+            pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
+            entries: dict[str, dict[str, str]] = pvi_structure["value"].todict()
+            # Ensure we have device vectors for everything that should be there
+            self._filler.make_device_vectors(list(entries))
+            for name, entry in entries.items():
+                if set(entry) == {"d"}:
+                    connector = self._filler.make_child_device(name)
+                    connector.pvi_pv = entry["d"]
+                else:
+                    signal_type, read_pv, write_pv = _get_signal_details(entry)
+                    backend = self._filler.make_child_signal(name, signal_type)
+                    backend.read_pv = read_pv
+                    backend.write_pv = write_pv
+            # Check that all the requested children have been created
+            if unfilled := self._filler.unfilled():
+                raise RuntimeError(
+                    f"{device.name}: cannot provision {unfilled} from "
+                    f"{self.pvi_pv}: {entries}"
+                )
+        # Set the name of the device to name all children
+        device.set_name(device.name)
+        return await super().connect(device, mock, timeout, force_reconnect)

ophyd_async/epics/signal/__init__.py

@@ -1,5 +1,5 @@
-from ._common import LimitPair, Limits, get_supported_values
-from ._p4p import PvaSignalBackend
+from ._common import get_supported_values
+from ._p4p import PvaSignalBackend, pvget_with_timeout
 from ._signal import (
     epics_signal_r,
     epics_signal_rw,
@@ -10,9 +10,8 @@ from ._signal import (
 
 __all__ = [
     "get_supported_values",
-    "LimitPair",
-    "Limits",
     "PvaSignalBackend",
+    "pvget_with_timeout",
     "epics_signal_r",
     "epics_signal_rw",
     "epics_signal_rw_rbv",