ophyd-async 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/epics/pvi/{pvi.py → _pvi.py}

@@ -10,25 +10,28 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    TypeVar,
     Union,
     get_args,
     get_origin,
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
-from ophyd_async.core.signal import Signal
-from ophyd_async.core.utils import DEFAULT_TIMEOUT
-from ophyd_async.epics._backend._p4p import PvaSignalBackend
-from ophyd_async.epics.signal.signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Device,
+    DeviceVector,
+    Signal,
+    SoftSignalBackend,
+    T,
+)
+from ophyd_async.epics.signal import (
+    PvaSignalBackend,
     epics_signal_r,
     epics_signal_rw,
     epics_signal_w,
     epics_signal_x,
 )
 
-T = TypeVar("T")
 Access = FrozenSet[
     Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
 ]
@@ -74,19 +77,19 @@ def _strip_device_vector(field: Union[Type[Device]]) -> Tuple[bool, Type[Device]
 
 
 @dataclass
-class PVIEntry:
+class _PVIEntry:
     """
     A dataclass to represent a single entry in the PVI table.
     This could either be a signal or a sub-table.
     """
 
-    sub_entries: Dict[str, Union[Dict[int, "PVIEntry"], "PVIEntry"]]
+    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
 
 
-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)
@@ -205,7 +208,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
         sub_device.parent = device
 
 
-async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
+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")
 
@@ -235,7 +238,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         else:
             device = getattr(entry.device, sub_name, device_type())
 
-        sub_entry = PVIEntry(
+        sub_entry = _PVIEntry(
             device=device, common_device_type=device_type, sub_entries={}
         )
 
@@ -257,7 +260,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         _verify_common_blocks(entry, entry.common_device_type)
 
 
-def _set_device_attributes(entry: PVIEntry):
+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
@@ -289,7 +292,7 @@ async def fill_pvi_entries(
         _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
-        root_entry = PVIEntry(
+        root_entry = _PVIEntry(
             pvi_pv=root_pv,
             device=device,
             common_device_type=type(device),

ophyd_async/epics/signal/__init__.py

@@ -1,4 +1,6 @@
-from .signal import (
+from ._common import LimitPair, Limits, get_supported_values
+from ._p4p import PvaSignalBackend
+from ._signal import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
@@ -7,6 +9,10 @@ from .signal import (
 )
 
 __all__ = [
+    "get_supported_values",
+    "LimitPair",
+    "Limits",
+    "PvaSignalBackend",
     "epics_signal_r",
     "epics_signal_rw",
     "epics_signal_rw_rbv",

ophyd_async/epics/{_backend → signal}/_aioca.py

@@ -21,6 +21,8 @@ from bluesky.protocols import DataKey, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -28,9 +30,8 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",

ophyd_async/epics/{_backend/common.py → signal/_common.py}

@@ -4,7 +4,7 @@ from typing import Dict, Optional, Tuple, Type
 
 from typing_extensions import TypedDict
 
-from ophyd_async.core.signal_backend import RuntimeSubsetEnum
+from ophyd_async.core import RuntimeSubsetEnum
 
 common_meta = {
     "units",

ophyd_async/epics/signal/_epics_transport.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from enum import Enum
 
 try:
-    from .._backend._aioca import CaSignalBackend
+    from ._aioca import CaSignalBackend
 except ImportError as ca_error:
 
     class CaSignalBackend:  # type: ignore
@@ -14,7 +14,7 @@ except ImportError as ca_error:
 
 
 try:
-    from .._backend._p4p import PvaSignalBackend
+    from ._p4p import PvaSignalBackend
 except ImportError as pva_error:
 
     class PvaSignalBackend:  # type: ignore
@@ -22,7 +22,7 @@ except ImportError as pva_error:
             raise NotImplementedError("PVA support not available") from pva_error
 
 
-class EpicsTransport(Enum):
+class _EpicsTransport(Enum):
     """The sorts of transport EPICS support"""
 
     #: Use Channel Access (using aioca library)

ophyd_async/epics/{_backend → signal}/_p4p.py

@@ -13,17 +13,18 @@ from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
+    RuntimeSubsetEnum,
     SignalBackend,
     T,
     get_dtype,
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.signal_backend import RuntimeSubsetEnum
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {

ophyd_async/epics/signal/{signal.py → _signal.py}

@@ -14,26 +14,27 @@ from ophyd_async.core import (
     get_unique,
 )
 
-from ._epics_transport import EpicsTransport
+from ._epics_transport import _EpicsTransport
 
-_default_epics_transport = EpicsTransport.ca
+_default_epics_transport = _EpicsTransport.ca
 
 
-def _transport_pv(pv: str) -> Tuple[EpicsTransport, str]:
+def _transport_pv(pv: str) -> Tuple[_EpicsTransport, 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]
+        transport = _EpicsTransport[transport_str]
     else:
         # No comms mode specified, use the default
         transport = _default_epics_transport
     return transport, pv
 
 
-def _make_backend(
+def _epics_signal_backend(
     datatype: Optional[Type[T]], read_pv: str, write_pv: str
 ) -> SignalBackend[T]:
+    """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")
@@ -54,7 +55,7 @@ def epics_signal_rw(
     write_pv:
         If given, use this PV to write to, otherwise use read_pv
     """
-    backend = _make_backend(datatype, read_pv, write_pv or read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
     return SignalRW(backend, name=name)
 
 
@@ -85,7 +86,7 @@ def epics_signal_r(datatype: Type[T], read_pv: str, name: str = "") -> SignalR[T
     read_pv:
         The PV to read and monitor
     """
-    backend = _make_backend(datatype, read_pv, read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, read_pv)
     return SignalR(backend, name=name)
 
 
@@ -99,7 +100,7 @@ def epics_signal_w(datatype: Type[T], write_pv: str, name: str = "") -> SignalW[
     write_pv:
         The PV to write to
     """
-    backend = _make_backend(datatype, write_pv, write_pv)
+    backend = _epics_signal_backend(datatype, write_pv, write_pv)
     return SignalW(backend, name=name)
 
 
@@ -111,5 +112,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 = _make_backend(None, write_pv, write_pv)
+    backend: SignalBackend = _epics_signal_backend(None, write_pv, write_pv)
     return SignalX(backend, name=name)

ophyd_async/{panda → fastcs/panda}/__init__.py

@@ -10,8 +10,11 @@ from ._common_blocks import (
     TimeUnits,
 )
 from ._hdf_panda import HDFPanda
+from ._hdf_writer import PandaHDFWriter
 from ._panda_controller import PandaPcapController
 from ._table import (
+    DatasetTable,
+    PandaHdf5DatasetType,
     SeqTable,
     SeqTableRow,
     SeqTrigger,
@@ -28,25 +31,27 @@ from ._utils import phase_sorter
 
 __all__ = [
     "CommonPandaBlocks",
-    "HDFPanda",
-    "PcompBlock",
-    "PcompInfo",
-    "PcompDirectionOptions",
+    "DataBlock",
     "EnableDisableOptions",
     "PcapBlock",
+    "PcompBlock",
+    "PcompDirectionOptions",
     "PulseBlock",
-    "seq_table_from_arrays",
-    "seq_table_from_rows",
     "SeqBlock",
-    "SeqTableInfo",
+    "TimeUnits",
+    "HDFPanda",
+    "PandaHDFWriter",
+    "PandaPcapController",
+    "DatasetTable",
+    "PandaHdf5DatasetType",
     "SeqTable",
     "SeqTableRow",
     "SeqTrigger",
-    "phase_sorter",
-    "PandaPcapController",
-    "TimeUnits",
-    "DataBlock",
-    "CommonPandABlocks",
-    "StaticSeqTableTriggerLogic",
+    "seq_table_from_arrays",
+    "seq_table_from_rows",
+    "PcompInfo",
+    "SeqTableInfo",
     "StaticPcompTriggerLogic",
+    "StaticSeqTableTriggerLogic",
+    "phase_sorter",
 ]

ophyd_async/{panda → fastcs/panda}/_common_blocks.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from enum import Enum
 
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW
-from ophyd_async.core.signal_backend import SubsetEnum
-from ophyd_async.panda._table import DatasetTable, SeqTable
+from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
+
+from ._table import DatasetTable, SeqTable
 
 
 class DataBlock(Device):

ophyd_async/{panda → fastcs/panda}/_hdf_panda.py

@@ -2,17 +2,12 @@ from __future__ import annotations
 
 from typing import Sequence
 
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    PathProvider,
-    SignalR,
-    StandardDetector,
-)
+from ophyd_async.core import DEFAULT_TIMEOUT, PathProvider, SignalR, StandardDetector
 from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
 
 from ._common_blocks import CommonPandaBlocks
+from ._hdf_writer import PandaHDFWriter
 from ._panda_controller import PandaPcapController
-from .writers._hdf_writer import PandaHDFWriter
 
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):

ophyd_async/{panda/writers → fastcs/panda}/_hdf_writer.py

@@ -8,14 +8,15 @@ from p4p.client.thread import Context
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorWriter,
+    HDFDataset,
+    HDFFile,
     NameProvider,
     PathProvider,
+    observe_value,
     wait_for_value,
 )
-from ophyd_async.core.signal import observe_value
-from ophyd_async.epics.areadetector.writers.general_hdffile import _HDFDataset, _HDFFile
 
-from .._common_blocks import CommonPandaBlocks
+from ._common_blocks import CommonPandaBlocks
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -32,8 +33,8 @@ class PandaHDFWriter(DetectorWriter):
         self._prefix = prefix
         self._path_provider = path_provider
         self._name_provider = name_provider
-        self._datasets: List[_HDFDataset] = []
-        self._file: Optional[_HDFFile] = None
+        self._datasets: List[HDFDataset] = []
+        self._file: Optional[HDFFile] = None
         self._multiplier = 1
 
     # Triggered on PCAP arm
@@ -93,7 +94,7 @@ class PandaHDFWriter(DetectorWriter):
 
         capture_table = await self.panda_device.data.datasets.get_value()
         self._datasets = [
-            _HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
+            HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
             for dataset_name in capture_table["name"]
         ]
 
@@ -128,7 +129,7 @@ class PandaHDFWriter(DetectorWriter):
         # TODO: fail if we get dropped frames
         if indices_written:
             if not self._file:
-                self._file = _HDFFile(
+                self._file = HDFFile(
                     self._path_provider(),
                     Path(await self.panda_device.data.hdf_directory.get_value())
                     / Path(await self.panda_device.data.hdf_file_name.get_value()),

ophyd_async/{panda → fastcs/panda}/_panda_controller.py

@@ -7,7 +7,8 @@ from ophyd_async.core import (
     DetectorTrigger,
     wait_for_value,
 )
-from ophyd_async.panda import PcapBlock
+
+from ._common_blocks import PcapBlock
 
 
 class PandaPcapController(DetectorControl):

ophyd_async/{panda → fastcs/panda}/_trigger.py

@@ -4,13 +4,9 @@ from typing import Optional
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import TriggerLogic, wait_for_value
-from ophyd_async.panda import (
-    PcompBlock,
-    PcompDirectionOptions,
-    SeqBlock,
-    SeqTable,
-    TimeUnits,
-)
+
+from ._common_blocks import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._table import SeqTable
 
 
 class SeqTableInfo(BaseModel):

ophyd_async/plan_stubs/__init__.py

@@ -1,5 +1,5 @@
-from .ensure_connected import ensure_connected
-from .fly import (
+from ._ensure_connected import ensure_connected
+from ._fly import (
     fly_and_collect,
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
     time_resolved_fly_and_collect_with_static_seq_table,

ophyd_async/plan_stubs/{ensure_connected.py → _ensure_connected.py}

@@ -1,7 +1,6 @@
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core.device import Device
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
 
 
 def ensure_connected(

ophyd_async/plan_stubs/{fly.py → _fly.py}

@@ -3,10 +3,14 @@ from typing import List, Optional
 import bluesky.plan_stubs as bps
 from bluesky.utils import short_uid
 
-from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
-from ophyd_async.core.flyer import HardwareTriggeredFlyable
-from ophyd_async.core.utils import in_micros
-from ophyd_async.panda import (
+from ophyd_async.core import (
+    DetectorTrigger,
+    StandardDetector,
+    StandardFlyer,
+    TriggerInfo,
+    in_micros,
+)
+from ophyd_async.fastcs.panda import (
     PcompDirectionOptions,
     PcompInfo,
     SeqTable,
@@ -17,7 +21,7 @@ from ophyd_async.panda import (
 
 
 def prepare_static_pcomp_flyer_and_detectors(
-    flyer: HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
     pcomp_info: PcompInfo,
     trigger_info: TriggerInfo,
@@ -36,7 +40,7 @@ def prepare_static_pcomp_flyer_and_detectors(
 
 
 def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,
@@ -100,7 +104,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 
 def fly_and_collect(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo] | HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
 ):
     """Kickoff, complete and collect with a flyer and multiple detectors.
@@ -140,7 +144,7 @@ def fly_and_collect(
 
 def fly_and_collect_with_static_pcomp(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
     number_of_pulses: int,
     pulse_width: int,
@@ -166,7 +170,7 @@ def fly_and_collect_with_static_pcomp(
 
 def time_resolved_fly_and_collect_with_static_seq_table(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,

ophyd_async/sim/__init__.py

@@ -1,11 +0,0 @@
-from .pattern_generator import PatternGenerator
-from .sim_pattern_detector_control import SimPatternDetectorControl
-from .sim_pattern_detector_writer import SimPatternDetectorWriter
-from .sim_pattern_generator import SimPatternDetector
-
-__all__ = [
-    "PatternGenerator",
-    "SimPatternDetectorControl",
-    "SimPatternDetectorWriter",
-    "SimPatternDetector",
-]

ophyd_async/sim/demo/__init__.py

@@ -1,3 +1,19 @@
-from .sim_motor import SimMotor
+from ._pattern_detector import (
+    DATA_PATH,
+    SUM_PATH,
+    PatternDetector,
+    PatternDetectorController,
+    PatternDetectorWriter,
+    PatternGenerator,
+)
+from ._sim_motor import SimMotor
 
-__all__ = ["SimMotor"]
+__all__ = [
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "SimMotor",
+]

ophyd_async/sim/demo/_pattern_detector/__init__.py

@@ -0,0 +1,13 @@
+from ._pattern_detector import PatternDetector
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import DATA_PATH, SUM_PATH, PatternGenerator
+
+__all__ = [
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+]

ophyd_async/sim/{sim_pattern_generator.py → demo/_pattern_detector/_pattern_detector.py}

@@ -2,20 +2,20 @@ from pathlib import Path
 from typing import Sequence
 
 from ophyd_async.core import (
+    AsyncReadable,
     FilenameProvider,
     PathProvider,
+    StandardDetector,
     StaticFilenameProvider,
     StaticPathProvider,
 )
-from ophyd_async.core.detector import StandardDetector
-from ophyd_async.protocols import AsyncReadable
-from ophyd_async.sim.pattern_generator import PatternGenerator
 
-from .sim_pattern_detector_control import SimPatternDetectorControl
-from .sim_pattern_detector_writer import SimPatternDetectorWriter
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import PatternGenerator
 
 
-class SimPatternDetector(StandardDetector):
+class PatternDetector(StandardDetector):
     def __init__(
         self,
         path: Path,
@@ -25,12 +25,12 @@ class SimPatternDetector(StandardDetector):
         fp: FilenameProvider = StaticFilenameProvider(name)
         self.path_provider: PathProvider = StaticPathProvider(fp, path)
         self.pattern_generator = PatternGenerator()
-        writer = SimPatternDetectorWriter(
+        writer = PatternDetectorWriter(
             pattern_generator=self.pattern_generator,
             path_provider=self.path_provider,
             name_provider=lambda: self.name,
         )
-        controller = SimPatternDetectorControl(
+        controller = PatternDetectorController(
             pattern_generator=self.pattern_generator,
             path_provider=self.path_provider,
         )

ophyd_async/sim/{sim_pattern_detector_control.py → demo/_pattern_detector/_pattern_detector_controller.py}

@@ -1,13 +1,12 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.detector import DetectorControl, DetectorTrigger
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorControl(DetectorControl):
+
+class PatternDetectorController(DetectorControl):
     def __init__(
         self,
         pattern_generator: PatternGenerator,

ophyd_async/sim/{sim_pattern_detector_writer.py → demo/_pattern_detector/_pattern_detector_writer.py}

@@ -2,12 +2,12 @@ from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import DataKey
 
-from ophyd_async.core import NameProvider, PathProvider
-from ophyd_async.core.detector import DetectorWriter
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import DetectorWriter, NameProvider, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorWriter(DetectorWriter):
+
+class PatternDetectorWriter(DetectorWriter):
     pattern_generator: PatternGenerator
 
     def __init__(