ophyd-async 0.3.4a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.4a1'
-__version_tuple__ = version_tuple = (0, 3, 4)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

ophyd_async/core/__init__.py

@@ -1,20 +1,13 @@
-from ._providers import (
-    DirectoryInfo,
-    DirectoryProvider,
-    NameProvider,
-    ShapeProvider,
-    StaticDirectoryProvider,
-)
-from .async_status import AsyncStatus, WatchableAsyncStatus
-from .detector import (
+from ._detector import (
     DetectorControl,
     DetectorTrigger,
     DetectorWriter,
     StandardDetector,
     TriggerInfo,
 )
-from .device import Device, DeviceCollector, DeviceVector
-from .device_save_loader import (
+from ._device import Device, DeviceCollector, DeviceVector
+from ._device_save_loader import (
+    all_at_once,
     get_signal_values,
     load_device,
     load_from_yaml,
@@ -23,9 +16,11 @@ from .device_save_loader import (
     set_signal_values,
     walk_rw_signals,
 )
-from .flyer import HardwareTriggeredFlyable, TriggerLogic
-from .mock_signal_backend import MockSignalBackend
-from .mock_signal_utils import (
+from ._flyer import StandardFlyer, TriggerLogic
+from ._hdf_dataset import HDFDataset, HDFFile
+from ._log import config_ophyd_async_logging
+from ._mock_signal_backend import MockSignalBackend
+from ._mock_signal_utils import (
     callback_on_mock_put,
     get_mock_put,
     mock_puts_blocked,
@@ -34,7 +29,22 @@ from .mock_signal_utils import (
     set_mock_value,
     set_mock_values,
 )
-from .signal import (
+from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
+from ._providers import (
+    AutoIncrementFilenameProvider,
+    AutoIncrementingPathProvider,
+    FilenameProvider,
+    NameProvider,
+    PathInfo,
+    PathProvider,
+    ShapeProvider,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    UUIDFilenameProvider,
+    YMDPathProvider,
+)
+from ._readable import ConfigSignal, HintedSignal, StandardReadable
+from ._signal import (
     Signal,
     SignalR,
     SignalRW,
@@ -50,87 +60,100 @@ from .signal import (
     soft_signal_rw,
     wait_for_value,
 )
-from .signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
-from .soft_signal_backend import SoftSignalBackend
-from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
-from .utils import (
+from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
+from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
+from ._status import AsyncStatus, WatchableAsyncStatus
+from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     CalculateTimeout,
-    Callback,
     NotConnected,
     ReadingValueCallback,
     T,
+    WatcherUpdate,
     get_dtype,
     get_unique,
-    merge_gathered_dicts,
+    in_micros,
     wait_for_connection,
 )
 
 __all__ = [
-    "AsyncStatus",
-    "CalculatableTimeout",
-    "CalculateTimeout",
-    "Callback",
-    "ConfigSignal",
-    "DEFAULT_TIMEOUT",
     "DetectorControl",
     "DetectorTrigger",
     "DetectorWriter",
+    "StandardDetector",
+    "TriggerInfo",
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "DirectoryInfo",
-    "DirectoryProvider",
-    "HardwareTriggeredFlyable",
-    "HintedSignal",
+    "all_at_once",
+    "get_signal_values",
+    "load_device",
+    "load_from_yaml",
+    "save_device",
+    "save_to_yaml",
+    "set_signal_values",
+    "walk_rw_signals",
+    "StandardFlyer",
+    "TriggerLogic",
+    "HDFDataset",
+    "HDFFile",
+    "config_ophyd_async_logging",
     "MockSignalBackend",
+    "callback_on_mock_put",
+    "get_mock_put",
+    "mock_puts_blocked",
+    "reset_mock_put_calls",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
+    "AsyncConfigurable",
+    "AsyncReadable",
+    "AsyncStageable",
+    "AutoIncrementFilenameProvider",
+    "AutoIncrementingPathProvider",
+    "FilenameProvider",
     "NameProvider",
-    "NotConnected",
-    "ReadingValueCallback",
-    "RuntimeSubsetEnum",
-    "SubsetEnum",
+    "PathInfo",
+    "PathProvider",
     "ShapeProvider",
+    "StaticFilenameProvider",
+    "StaticPathProvider",
+    "UUIDFilenameProvider",
+    "YMDPathProvider",
+    "ConfigSignal",
+    "HintedSignal",
+    "StandardReadable",
     "Signal",
-    "SignalBackend",
     "SignalR",
     "SignalRW",
     "SignalW",
     "SignalX",
-    "SoftSignalBackend",
-    "StandardDetector",
-    "StandardReadable",
-    "StaticDirectoryProvider",
-    "T",
-    "TriggerInfo",
-    "TriggerLogic",
-    "WatchableAsyncStatus",
     "assert_configuration",
     "assert_emitted",
-    "assert_mock_put_called_with",
     "assert_reading",
     "assert_value",
-    "callback_on_mock_put",
-    "get_dtype",
-    "get_mock_put",
-    "get_signal_values",
-    "get_unique",
-    "load_device",
-    "load_from_yaml",
-    "merge_gathered_dicts",
-    "mock_puts_blocked",
     "observe_value",
-    "reset_mock_put_calls",
-    "save_device",
-    "save_to_yaml",
     "set_and_wait_for_value",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "set_mock_values",
-    "set_signal_values",
     "soft_signal_r_and_setter",
     "soft_signal_rw",
-    "wait_for_connection",
     "wait_for_value",
-    "walk_rw_signals",
+    "RuntimeSubsetEnum",
+    "SignalBackend",
+    "SubsetEnum",
+    "SignalMetadata",
+    "SoftSignalBackend",
+    "AsyncStatus",
+    "WatchableAsyncStatus",
+    "DEFAULT_TIMEOUT",
+    "CalculatableTimeout",
+    "CalculateTimeout",
+    "NotConnected",
+    "ReadingValueCallback",
+    "T",
+    "WatcherUpdate",
+    "get_dtype",
+    "get_unique",
+    "in_micros",
+    "wait_for_connection",
 ]

ophyd_async/core/{detector.py → _detector.py}

@@ -3,7 +3,6 @@
 import asyncio
 import time
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
 from enum import Enum
 from typing import (
     AsyncGenerator,
@@ -14,7 +13,6 @@ from typing import (
     List,
     Optional,
     Sequence,
-    TypeVar,
 )
 
 from bluesky.protocols import (
@@ -28,14 +26,12 @@ from bluesky.protocols import (
     Triggerable,
     WritesStreamAssets,
 )
+from pydantic import BaseModel, Field
 
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
-
-from .async_status import AsyncStatus, WatchableAsyncStatus
-from .device import Device
-from .utils import DEFAULT_TIMEOUT, WatcherUpdate, merge_gathered_dicts
-
-T = TypeVar("T")
+from ._device import Device
+from ._protocol import AsyncConfigurable, AsyncReadable
+from ._status import AsyncStatus, WatchableAsyncStatus
+from ._utils import DEFAULT_TIMEOUT, T, WatcherUpdate, merge_gathered_dicts
 
 
 class DetectorTrigger(str, Enum):
@@ -51,20 +47,19 @@ class DetectorTrigger(str, Enum):
     variable_gate = "variable_gate"
 
 
-@dataclass(frozen=True)
-class TriggerInfo:
+class TriggerInfo(BaseModel):
     """Minimal set of information required to setup triggering on a detector"""
 
-    #: Number of triggers that will be sent
-    num: int
+    #: Number of triggers that will be sent, 0 means infinite
+    number: int = Field(gt=0)
     #: Sort of triggers that will be sent
-    trigger: DetectorTrigger
+    trigger: DetectorTrigger = Field()
     #: What is the minimum deadtime between triggers
-    deadtime: float
+    deadtime: float = Field(ge=0)
     #: What is the maximum high time of the triggers
-    livetime: float
+    livetime: float = Field(ge=0)
     #: What is the maximum timeout on waiting for a frame
-    frame_timeout: float | None = None
+    frame_timeout: float | None = Field(None, gt=0)
 
 
 class DetectorControl(ABC):
@@ -243,12 +238,12 @@ class StandardDetector(
     async def trigger(self) -> None:
         # set default trigger_info
         self._trigger_info = TriggerInfo(
-            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+            number=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
         )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=self._trigger_info.num,
+            num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
         )
         await written_status
@@ -285,7 +280,7 @@ class StandardDetector(
         assert type(value) is TriggerInfo
         self._trigger_info = value
         self._initial_frame = await self.writer.get_indices_written()
-        self._last_frame = self._initial_frame + self._trigger_info.num
+        self._last_frame = self._initial_frame + self._trigger_info.number
 
         required = self.controller.get_deadtime(self._trigger_info.livetime)
         assert required <= self._trigger_info.deadtime, (
@@ -293,7 +288,7 @@ class StandardDetector(
             f"but trigger logic provides only {self._trigger_info.deadtime}s"
         )
         self._arm_status = await self.controller.arm(
-            num=self._trigger_info.num,
+            num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
             exposure=self._trigger_info.livetime,
         )
@@ -320,12 +315,12 @@ class StandardDetector(
                 name=self.name,
                 current=index,
                 initial=self._initial_frame,
-                target=self._trigger_info.num,
+                target=self._trigger_info.number,
                 unit="",
                 precision=0,
                 time_elapsed=time.monotonic() - self._fly_start,
             )
-            if index >= self._trigger_info.num:
+            if index >= self._trigger_info.number:
                 break
 
     async def describe_collect(self) -> Dict[str, DataKey]:

ophyd_async/core/{device.py → _device.py}

@@ -19,7 +19,7 @@ from typing import (
 from bluesky.protocols import HasName
 from bluesky.run_engine import call_in_bluesky_event_loop
 
-from .utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
+from ._utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
 
 
 class Device(HasName):
@@ -33,7 +33,10 @@ class Device(HasName):
     parent: Optional["Device"] = None
     # None if connect hasn't started, a Task if it has
     _connect_task: Optional[asyncio.Task] = None
-    _connect_mock_arg: bool = False
+
+    # Used to check if the previous connect was mocked,
+    # if the next mock value differs then we fail
+    _previous_connect_was_mock = None
 
     def __init__(self, name: str = "") -> None:
         self.set_name(name)
@@ -90,11 +93,21 @@ class Device(HasName):
         timeout:
             Time to wait before failing with a TimeoutError.
         """
+
+        if (
+            self._previous_connect_was_mock is not None
+            and self._previous_connect_was_mock != mock
+        ):
+            raise RuntimeError(
+                f"`connect(mock={mock})` called on a `Device` where the previous "
+                f"connect was `mock={self._previous_connect_was_mock}`. Changing mock "
+                "value between connects is not permitted."
+            )
+        self._previous_connect_was_mock = mock
+
         # If previous connect with same args has started and not errored, can use it
-        can_use_previous_connect = (
-            self._connect_task
-            and not (self._connect_task.done() and self._connect_task.exception())
-            and self._connect_mock_arg == mock
+        can_use_previous_connect = self._connect_task and not (
+            self._connect_task.done() and self._connect_task.exception()
         )
         if force_reconnect or not can_use_previous_connect:
             # Kick off a connection
@@ -105,7 +118,6 @@ class Device(HasName):
                 for name, child_device in self.children()
             }
             self._connect_task = asyncio.create_task(wait_for_connection(**coros))
-            self._connect_mock_arg = mock
 
         assert self._connect_task, "Connect task not created, this shouldn't happen"
         # Wait for it to complete

ophyd_async/core/{device_save_loader.py → _device_save_loader.py}

@@ -8,8 +8,8 @@ from bluesky.plan_stubs import abs_set, wait
 from bluesky.protocols import Location
 from bluesky.utils import Msg
 
-from .device import Device
-from .signal import SignalRW
+from ._device import Device
+from ._signal import SignalRW
 
 
 def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
@@ -241,7 +241,7 @@ def save_device(
     Therefore, users should consider the order of device loading and write their
     own sorter algorithms accordingly.
 
-    See :func:`ophyd_async.panda.phase_sorter` for a valid implementation of the
+    See :func:`ophyd_async.fastcs.panda.phase_sorter` for a valid implementation of the
     sorter.
 
     Parameters

ophyd_async/core/{flyer.py → _flyer.py}

@@ -1,14 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Generic, Sequence, TypeVar
+from typing import Dict, Generic, Sequence
 
 from bluesky.protocols import DataKey, Flyable, Preparable, Reading, Stageable
 
-from .async_status import AsyncStatus
-from .device import Device
-from .signal import SignalR
-from .utils import merge_gathered_dicts
-
-T = TypeVar("T")
+from ._device import Device
+from ._signal import SignalR
+from ._status import AsyncStatus
+from ._utils import T, merge_gathered_dicts
 
 
 class TriggerLogic(ABC, Generic[T]):
@@ -29,7 +27,7 @@ class TriggerLogic(ABC, Generic[T]):
         """Stop flying and wait everything to be stopped"""
 
 
-class HardwareTriggeredFlyable(
+class StandardFlyer(
     Device,
     Stageable,
     Preparable,

ophyd_async/core/_hdf_dataset.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator, List, Sequence
+from urllib.parse import urlunparse
+
+from event_model import (
+    ComposeStreamResource,
+    ComposeStreamResourceBundle,
+    StreamDatum,
+    StreamResource,
+)
+
+from ._providers import PathInfo
+
+
+@dataclass
+class HDFDataset:
+    data_key: str
+    dataset: str
+    shape: Sequence[int] = field(default_factory=tuple)
+    dtype_numpy: str = ""
+    multiplier: int = 1
+    swmr: bool = False
+
+
+SLICE_NAME = "AD_HDF5_SWMR_SLICE"
+
+
+class HDFFile:
+    """
+    :param directory_info: Contains information about how to construct a StreamResource
+    :param full_file_name: Absolute path to the file to be written
+    :param datasets: Datasets to write into the file
+    """
+
+    def __init__(
+        self,
+        path_info: PathInfo,
+        full_file_name: Path,
+        datasets: List[HDFDataset],
+        hostname: str = "localhost",
+    ) -> None:
+        self._last_emitted = 0
+        self._hostname = hostname
+
+        if len(datasets) == 0:
+            self._bundles = []
+            return None
+
+        bundler_composer = ComposeStreamResource()
+
+        uri = urlunparse(
+            (
+                "file",
+                self._hostname,
+                str((path_info.root / full_file_name).absolute()),
+                "",
+                "",
+                None,
+            )
+        )
+
+        self._bundles: List[ComposeStreamResourceBundle] = [
+            bundler_composer(
+                mimetype="application/x-hdf5",
+                uri=uri,
+                data_key=ds.data_key,
+                parameters={
+                    "dataset": ds.dataset,
+                    "swmr": ds.swmr,
+                    "multiplier": ds.multiplier,
+                },
+                uid=None,
+                validate=True,
+            )
+            for ds in datasets
+        ]
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
+            self._last_emitted = indices_written
+            for bundle in self._bundles:
+                yield bundle.compose_stream_datum(indices)
+        return None
+
+    def close(self) -> None:
+        for bundle in self._bundles:
+            bundle.close()

ophyd_async/{log.py → core/_log.py}

@@ -34,9 +34,7 @@ class ColoredFormatterWithDeviceName(colorlog.ColoredFormatter):
 
 
 def _validate_level(level) -> int:
-    """
-    Return an int for level comparison
-    """
+    """Return an int for level comparison."""
     if isinstance(level, int):
         levelno = level
     elif isinstance(level, str):
@@ -80,21 +78,31 @@ def config_ophyd_async_logging(
     level : str or int
         Python logging level, given as string or corresponding integer.
         Default is 'WARNING'.
+
     Returns
     -------
     handler : logging.Handler
         The handler, which has already been added to the 'ophyd_async' logger.
+
     Examples
     --------
     Log to a file.
+
         config_ophyd_async_logging(file='/tmp/what_is_happening.txt')
+
     Include the date along with the time. (The log messages will always include
     microseconds, which are configured separately, not as part of 'datefmt'.)
+
         config_ophyd_async_logging(datefmt="%Y-%m-%d %H:%M:%S")
+
     Turn off ANSI color codes.
+
         config_ophyd_async_logging(color=False)
+
     Increase verbosity: show level DEBUG or higher.
+
         config_ophyd_async_logging(level='DEBUG')
+
     """
     global current_handler
 

ophyd_async/core/{mock_signal_backend.py → _mock_signal_backend.py}

@@ -5,9 +5,9 @@ from unittest.mock import Mock
 
 from bluesky.protocols import Descriptor, Reading
 
-from ophyd_async.core.signal_backend import SignalBackend
-from ophyd_async.core.soft_signal_backend import SoftSignalBackend
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
+from ._signal_backend import SignalBackend
+from ._soft_signal_backend import SoftSignalBackend
+from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
 class MockSignalBackend(SignalBackend[T]):

ophyd_async/core/{mock_signal_utils.py → _mock_signal_utils.py}

@@ -2,10 +2,9 @@ from contextlib import asynccontextmanager, contextmanager
 from typing import Any, Callable, Iterable
 from unittest.mock import Mock
 
-from ophyd_async.core.signal import Signal
-from ophyd_async.core.utils import T
-
-from .mock_signal_backend import MockSignalBackend
+from ._mock_signal_backend import MockSignalBackend
+from ._signal import Signal
+from ._utils import T
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:

ophyd_async/{protocols.py → core/_protocol.py}

@@ -14,7 +14,7 @@ from typing import (
 from bluesky.protocols import DataKey, HasName, Reading
 
 if TYPE_CHECKING:
-    from ophyd_async.core.async_status import AsyncStatus
+    from ._status import AsyncStatus
 
 
 @runtime_checkable