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

ophyd_async/epics/signal/_signal.py

@@ -2,46 +2,81 @@
 
 from __future__ import annotations
 
+from enum import Enum
+
 from ophyd_async.core import (
     SignalBackend,
+    SignalDatatypeT,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
-    T,
     get_unique,
 )
 
-from ._epics_transport import _EpicsTransport
 
-_default_epics_transport = _EpicsTransport.ca
+def _make_unavailable_class(error: Exception) -> type:
+    class TransportNotAvailable:
+        def __init__(*args, **kwargs):
+            raise NotImplementedError("Transport not available") from error
+
+    return TransportNotAvailable
+
+
+class EpicsProtocol(Enum):
+    CA = "ca"
+    PVA = "pva"
+
+
+_default_epics_protocol = EpicsProtocol.CA
+
+try:
+    from ._p4p import PvaSignalBackend
+except ImportError as pva_error:
+    PvaSignalBackend = _make_unavailable_class(pva_error)
+else:
+    _default_epics_protocol = EpicsProtocol.PVA
+
+try:
+    from ._aioca import CaSignalBackend
+except ImportError as ca_error:
+    CaSignalBackend = _make_unavailable_class(ca_error)
+else:
+    _default_epics_protocol = EpicsProtocol.CA
 
 
-def _transport_pv(pv: str) -> tuple[_EpicsTransport, str]:
+def _protocol_pv(pv: str) -> tuple[EpicsProtocol, str]:
     split = pv.split("://", 1)
     if len(split) > 1:
         # We got something like pva://mydevice, so use specified comms mode
-        transport_str, pv = split
-        transport = _EpicsTransport[transport_str]
+        scheme, pv = split
+        protocol = EpicsProtocol(scheme)
     else:
         # No comms mode specified, use the default
-        transport = _default_epics_transport
-    return transport, pv
+        protocol = _default_epics_protocol
+    return protocol, pv
 
 
 def _epics_signal_backend(
-    datatype: type[T] | None, read_pv: str, write_pv: str
-) -> SignalBackend[T]:
+    datatype: type[SignalDatatypeT] | None, read_pv: str, write_pv: str
+) -> SignalBackend[SignalDatatypeT]:
     """Create an epics signal backend."""
-    r_transport, r_pv = _transport_pv(read_pv)
-    w_transport, w_pv = _transport_pv(write_pv)
-    transport = get_unique({read_pv: r_transport, write_pv: w_transport}, "transports")
-    return transport.value(datatype, r_pv, w_pv)
+    r_protocol, r_pv = _protocol_pv(read_pv)
+    w_protocol, w_pv = _protocol_pv(write_pv)
+    protocol = get_unique({read_pv: r_protocol, write_pv: w_protocol}, "protocols")
+    match protocol:
+        case EpicsProtocol.CA:
+            return CaSignalBackend(datatype, r_pv, w_pv)
+        case EpicsProtocol.PVA:
+            return PvaSignalBackend(datatype, r_pv, w_pv)
 
 
 def epics_signal_rw(
-    datatype: type[T], read_pv: str, write_pv: str | None = None, name: str = ""
-) -> SignalRW[T]:
+    datatype: type[SignalDatatypeT],
+    read_pv: str,
+    write_pv: str | None = None,
+    name: str = "",
+) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs
 
     Parameters
@@ -58,8 +93,11 @@ def epics_signal_rw(
 
 
 def epics_signal_rw_rbv(
-    datatype: type[T], write_pv: str, read_suffix: str = "_RBV", name: str = ""
-) -> SignalRW[T]:
+    datatype: type[SignalDatatypeT],
+    write_pv: str,
+    read_suffix: str = "_RBV",
+    name: str = "",
+) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv
 
     Parameters
@@ -74,7 +112,9 @@ def epics_signal_rw_rbv(
     return epics_signal_rw(datatype, f"{write_pv}{read_suffix}", write_pv, name)
 
 
-def epics_signal_r(datatype: type[T], read_pv: str, name: str = "") -> SignalR[T]:
+def epics_signal_r(
+    datatype: type[SignalDatatypeT], read_pv: str, name: str = ""
+) -> SignalR[SignalDatatypeT]:
     """Create a `SignalR` backed by 1 EPICS PV
 
     Parameters
@@ -88,7 +128,9 @@ def epics_signal_r(datatype: type[T], read_pv: str, name: str = "") -> SignalR[T
     return SignalR(backend, name=name)
 
 
-def epics_signal_w(datatype: type[T], write_pv: str, name: str = "") -> SignalW[T]:
+def epics_signal_w(
+    datatype: type[SignalDatatypeT], write_pv: str, name: str = ""
+) -> SignalW[SignalDatatypeT]:
     """Create a `SignalW` backed by 1 EPICS PVs
 
     Parameters
@@ -110,5 +152,5 @@ def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
     write_pv:
         The PV to write its initial value to on trigger
     """
-    backend: SignalBackend = _epics_signal_backend(None, write_pv, write_pv)
+    backend = _epics_signal_backend(None, write_pv, write_pv)
     return SignalX(backend, name=name)

ophyd_async/fastcs/core.py

@@ -0,0 +1,9 @@
+from ophyd_async.core import Device, DeviceConnector
+from ophyd_async.epics.pvi import PviDeviceConnector
+
+
+def fastcs_connector(device: Device, uri: str) -> DeviceConnector:
+    # TODO: add Tango support based on uri scheme
+    connector = PviDeviceConnector(uri + "PVI")
+    connector.create_children_from_annotations(device)
+    return connector

ophyd_async/fastcs/panda/__init__.py

@@ -1,10 +1,10 @@
 from ._block import (
+    BitMux,
     CommonPandaBlocks,
     DataBlock,
-    EnableDisableOptions,
     PcapBlock,
     PcompBlock,
-    PcompDirectionOptions,
+    PcompDirection,
     PulseBlock,
     SeqBlock,
     TimeUnits,
@@ -29,10 +29,10 @@ from ._writer import PandaHDFWriter
 __all__ = [
     "CommonPandaBlocks",
     "DataBlock",
-    "EnableDisableOptions",
+    "BitMux",
     "PcapBlock",
     "PcompBlock",
-    "PcompDirectionOptions",
+    "PcompDirection",
     "PulseBlock",
     "SeqBlock",
     "TimeUnits",

ophyd_async/fastcs/panda/_block.py

@@ -1,13 +1,16 @@
-from __future__ import annotations
-
-from enum import Enum
-
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
+from ophyd_async.core import (
+    Device,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+    SubsetEnum,
+)
 
 from ._table import DatasetTable, SeqTable
 
 
-class CaptureMode(str, Enum):
+class CaptureMode(StrictEnum):
     FIRST_N = "FIRST_N"
     LAST_N = "LAST_N"
     FOREVER = "FOREVER"
@@ -32,26 +35,28 @@ class PulseBlock(Device):
     width: SignalRW[float]
 
 
-class PcompDirectionOptions(str, Enum):
+class PcompDirection(StrictEnum):
     positive = "Positive"
     negative = "Negative"
     either = "Either"
 
 
-EnableDisableOptions = SubsetEnum["ZERO", "ONE"]
+class BitMux(SubsetEnum):
+    zero = "ZERO"
+    one = "ONE"
 
 
 class PcompBlock(Device):
     active: SignalR[bool]
-    dir: SignalRW[PcompDirectionOptions]
-    enable: SignalRW[EnableDisableOptions]
+    dir: SignalRW[PcompDirection]
+    enable: SignalRW[BitMux]
     pulses: SignalRW[int]
     start: SignalRW[int]
     step: SignalRW[int]
     width: SignalRW[int]
 
 
-class TimeUnits(str, Enum):
+class TimeUnits(StrictEnum):
     min = "min"
     s = "s"
     ms = "ms"
@@ -60,11 +65,11 @@ class TimeUnits(str, Enum):
 
 class SeqBlock(Device):
     table: SignalRW[SeqTable]
-    active: SignalRW[bool]
+    active: SignalR[bool]
     repeats: SignalRW[int]
     prescale: SignalRW[float]
     prescale_units: SignalRW[TimeUnits]
-    enable: SignalRW[EnableDisableOptions]
+    enable: SignalRW[BitMux]
 
 
 class PcapBlock(Device):

ophyd_async/fastcs/panda/_control.py

@@ -1,12 +1,10 @@
-import asyncio
-
 from ophyd_async.core import (
+    AsyncStatus,
     DetectorController,
     DetectorTrigger,
+    TriggerInfo,
     wait_for_value,
 )
-from ophyd_async.core._detector import TriggerInfo
-from ophyd_async.core._status import AsyncStatus
 
 from ._block import PcapBlock
 
@@ -33,5 +31,5 @@ class PandaPcapController(DetectorController):
         pass
 
     async def disarm(self):
-        await asyncio.gather(self.pcap.arm.set(False))
+        await self.pcap.arm.set(False)
         await wait_for_value(self.pcap.active, False, timeout=1)

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from ophyd_async.core import DEFAULT_TIMEOUT, PathProvider, SignalR, StandardDetector
-from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.fastcs.core import fastcs_connector
 
 from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
@@ -18,12 +18,10 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
-        self._prefix = prefix
-
-        create_children_from_annotations(self)
+        # This has to be first so we make self.pcap
+        connector = fastcs_connector(self, prefix)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
-            prefix=prefix,
             path_provider=path_provider,
             name_provider=lambda: name,
             panda_data_block=self.data,
@@ -33,17 +31,5 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-        )
-
-    async def connect(
-        self,
-        mock: bool = False,
-        timeout: float = DEFAULT_TIMEOUT,
-        force_reconnect: bool = False,
-    ):
-        # TODO: this doesn't support caching
-        # https://github.com/bluesky/ophyd-async/issues/472
-        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
-        await super().connect(
-            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+            connector=connector,
         )

ophyd_async/fastcs/panda/_table.py

@@ -1,27 +1,22 @@
 from collections.abc import Sequence
-from enum import Enum
-from typing import Annotated
 
 import numpy as np
-import numpy.typing as npt
-from pydantic import Field, model_validator
-from pydantic_numpy.helper.annotation import NpArrayPydanticAnnotation
-from typing_extensions import TypedDict
+from pydantic import model_validator
 
-from ophyd_async.core import Table
+from ophyd_async.core import Array1D, StrictEnum, Table
 
 
-class PandaHdf5DatasetType(str, Enum):
+class PandaHdf5DatasetType(StrictEnum):
     FLOAT_64 = "float64"
     UINT_32 = "uint32"
 
 
-class DatasetTable(TypedDict):
-    name: npt.NDArray[np.str_]
+class DatasetTable(Table):
+    name: Sequence[str]
     hdf5_type: Sequence[PandaHdf5DatasetType]
 
 
-class SeqTrigger(str, Enum):
+class SeqTrigger(StrictEnum):
     IMMEDIATE = "Immediate"
     BITA_0 = "BITA=0"
     BITA_1 = "BITA=1"
@@ -37,45 +32,27 @@ class SeqTrigger(str, Enum):
     POSC_LT = "POSC<=POSITION"
 
 
-PydanticNp1DArrayInt32 = Annotated[
-    np.ndarray[tuple[int], np.dtype[np.int32]],
-    NpArrayPydanticAnnotation.factory(
-        data_type=np.int32, dimensions=1, strict_data_typing=False
-    ),
-    Field(default_factory=lambda: np.array([], np.int32)),
-]
-PydanticNp1DArrayBool = Annotated[
-    np.ndarray[tuple[int], np.dtype[np.bool_]],
-    NpArrayPydanticAnnotation.factory(
-        data_type=np.bool_, dimensions=1, strict_data_typing=False
-    ),
-    Field(default_factory=lambda: np.array([], dtype=np.bool_)),
-]
-TriggerStr = Annotated[Sequence[SeqTrigger], Field(default_factory=list)]
-
-
 class SeqTable(Table):
-    repeats: PydanticNp1DArrayInt32
-    trigger: TriggerStr
-    position: PydanticNp1DArrayInt32
-    time1: PydanticNp1DArrayInt32
-    outa1: PydanticNp1DArrayBool
-    outb1: PydanticNp1DArrayBool
-    outc1: PydanticNp1DArrayBool
-    outd1: PydanticNp1DArrayBool
-    oute1: PydanticNp1DArrayBool
-    outf1: PydanticNp1DArrayBool
-    time2: PydanticNp1DArrayInt32
-    outa2: PydanticNp1DArrayBool
-    outb2: PydanticNp1DArrayBool
-    outc2: PydanticNp1DArrayBool
-    outd2: PydanticNp1DArrayBool
-    oute2: PydanticNp1DArrayBool
-    outf2: PydanticNp1DArrayBool
+    repeats: Array1D[np.uint16]
+    trigger: Sequence[SeqTrigger]
+    position: Array1D[np.int32]
+    time1: Array1D[np.uint32]
+    outa1: Array1D[np.bool_]
+    outb1: Array1D[np.bool_]
+    outc1: Array1D[np.bool_]
+    outd1: Array1D[np.bool_]
+    oute1: Array1D[np.bool_]
+    outf1: Array1D[np.bool_]
+    time2: Array1D[np.uint32]
+    outa2: Array1D[np.bool_]
+    outb2: Array1D[np.bool_]
+    outc2: Array1D[np.bool_]
+    outd2: Array1D[np.bool_]
+    oute2: Array1D[np.bool_]
+    outf2: Array1D[np.bool_]
 
-    @classmethod
-    def row(  # type: ignore
-        cls,
+    @staticmethod
+    def row(
         *,
         repeats: int = 1,
         trigger: str = SeqTrigger.IMMEDIATE,
@@ -95,7 +72,8 @@ class SeqTable(Table):
         oute2: bool = False,
         outf2: bool = False,
     ) -> "SeqTable":
-        return Table.row(**locals())
+        # Let pydantic do the conversions for us
+        return SeqTable(**{k: [v] for k, v in locals().items()})  # type: ignore
 
     @model_validator(mode="after")
     def validate_max_length(self) -> "SeqTable":
@@ -104,6 +82,6 @@ class SeqTable(Table):
         the pydantic field doesn't work
         """
 
-        first_length = len(next(iter(self))[1])
-        assert 0 <= first_length < 4096, f"Length {first_length} not in range."
+        first_length = len(self)
+        assert first_length <= 4096, f"Length {first_length} is too long"
         return self

ophyd_async/fastcs/panda/_trigger.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel, Field
 
 from ophyd_async.core import FlyerController, wait_for_value
 
-from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._block import BitMux, PcompBlock, PcompDirection, SeqBlock, TimeUnits
 from ._table import SeqTable
 
 
@@ -21,7 +21,7 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
     async def prepare(self, value: SeqTableInfo):
         await asyncio.gather(
             self.seq.prescale_units.set(TimeUnits.us),
-            self.seq.enable.set("ZERO"),
+            self.seq.enable.set(BitMux.zero),
         )
         await asyncio.gather(
             self.seq.prescale.set(value.prescale_as_us),
@@ -30,14 +30,14 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.seq.enable.set("ONE")
+        await self.seq.enable.set(BitMux.one)
         await wait_for_value(self.seq.active, True, timeout=1)
 
     async def complete(self) -> None:
         await wait_for_value(self.seq.active, False, timeout=None)
 
     async def stop(self):
-        await self.seq.enable.set("ZERO")
+        await self.seq.enable.set(BitMux.zero)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
@@ -54,7 +54,7 @@ class PcompInfo(BaseModel):
         ),
         ge=0,
     )
-    direction: PcompDirectionOptions = Field(
+    direction: PcompDirection = Field(
         description=(
             "Specifies which direction the motor counts should be "
             "moving. Pulses won't be sent unless the values are moving in "
@@ -68,7 +68,7 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set("ZERO")
+        await self.pcomp.enable.set(BitMux.zero)
         await asyncio.gather(
             self.pcomp.start.set(value.start_postion),
             self.pcomp.width.set(value.pulse_width),
@@ -78,12 +78,12 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.pcomp.enable.set("ONE")
+        await self.pcomp.enable.set(BitMux.one)
         await wait_for_value(self.pcomp.active, True, timeout=1)
 
     async def complete(self, timeout: float | None = None) -> None:
         await wait_for_value(self.pcomp.active, False, timeout=timeout)
 
     async def stop(self):
-        await self.pcomp.enable.set("ZERO")
+        await self.pcomp.enable.set(BitMux.zero)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/fastcs/panda/_writer.py

@@ -25,13 +25,11 @@ class PandaHDFWriter(DetectorWriter):
 
     def __init__(
         self,
-        prefix: str,
         path_provider: PathProvider,
         name_provider: NameProvider,
         panda_data_block: DataBlock,
     ) -> None:
         self.panda_data_block = panda_data_block
-        self._prefix = prefix
         self._path_provider = path_provider
         self._name_provider = name_provider
         self._datasets: list[HDFDataset] = []
@@ -89,8 +87,7 @@ class PandaHDFWriter(DetectorWriter):
                 shape=list(ds.shape),
                 dtype="array" if ds.shape != [1] else "number",
                 # PandA data should always be written as Float64
-                # Ignore type check until https://github.com/bluesky/event-model/issues/308
-                dtype_numpy="<f8",  # type: ignore
+                dtype_numpy="<f8",
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -110,7 +107,7 @@ class PandaHDFWriter(DetectorWriter):
             HDFDataset(
                 dataset_name, "/" + dataset_name, [1], multiplier=1, chunk_shape=(1024,)
             )
-            for dataset_name in capture_table["name"]
+            for dataset_name in capture_table.name
         ]
 
         # Warn user if dataset table is empty in PandA

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,3 +1,5 @@
+from unittest.mock import Mock
+
 import bluesky.plan_stubs as bps
 
 from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
@@ -5,7 +7,7 @@ from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
 
 def ensure_connected(
     *devices: Device,
-    mock: bool = False,
+    mock: bool | Mock = False,
     timeout: float = DEFAULT_TIMEOUT,
     force_reconnect=False,
 ):

ophyd_async/plan_stubs/_fly.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     in_micros,
 )
 from ophyd_async.fastcs.panda import (
-    PcompDirectionOptions,
+    PcompDirection,
     PcompInfo,
     SeqTable,
     SeqTableInfo,
@@ -147,7 +147,7 @@ def fly_and_collect_with_static_pcomp(
     number_of_pulses: int,
     pulse_width: int,
     rising_edge_step: int,
-    direction: PcompDirectionOptions,
+    direction: PcompDirection,
     trigger_info: TriggerInfo,
 ):
     # Set up scan and prepare trigger

ophyd_async/plan_stubs/_nd_attributes.py

@@ -16,12 +16,12 @@ from ophyd_async.epics.adcore import (
 def setup_ndattributes(
     device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
 ):
-    xml_text = ET.Element("Attributes")
+    root = ET.Element("Attributes")
 
     for ndattribute in ndattributes:
         if isinstance(ndattribute, NDAttributeParam):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="PARAM",
@@ -32,7 +32,7 @@ def setup_ndattributes(
             )
         elif isinstance(ndattribute, NDAttributePv):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="EPICS_PV",
@@ -45,7 +45,8 @@ def setup_ndattributes(
                 f"Invalid type for ndattributes: {type(ndattribute)}. "
                 "Expected NDAttributePv or NDAttributeParam."
             )
-    yield from bps.mv(device.nd_attributes_file, xml_text)
+    xml_text = ET.tostring(root, encoding="unicode")
+    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
 
 
 def setup_ndstats_sum(detector: Device):

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,7 +1,6 @@
 import asyncio
 
-from ophyd_async.core import DetectorController, PathProvider
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import DetectorController, PathProvider, TriggerInfo
 
 from ._pattern_generator import PatternGenerator
 

ophyd_async/tango/__init__.py

@@ -7,14 +7,13 @@ from .signal import (
     AttributeProxy,
     CommandProxy,
     TangoSignalBackend,
-    __tango_signal_auto,
     ensure_proper_executor,
     get_dtype_extended,
     get_python_type,
     get_tango_trl,
     get_trl_descriptor,
     infer_python_type,
-    infer_signal_character,
+    infer_signal_type,
     make_backend,
     tango_signal_r,
     tango_signal_rw,
@@ -32,12 +31,11 @@ __all__ = [
     "get_trl_descriptor",
     "get_tango_trl",
     "infer_python_type",
-    "infer_signal_character",
+    "infer_signal_type",
     "make_backend",
     "AttributeProxy",
     "CommandProxy",
     "ensure_proper_executor",
-    "__tango_signal_auto",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",