ophyd-async 0.11__py3-none-any.whl → 0.12.1__py3-none-any.whl

ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.11'
-__version_tuple__ = version_tuple = (0, 11)
+__version__ = version = '0.12.1'
+__version_tuple__ = version_tuple = (0, 12, 1)

ophyd_async/core/_flyer.py

@@ -17,15 +17,15 @@ class FlyerController(ABC, Generic[T]):
 
     @abstractmethod
     async def prepare(self, value: T) -> Any:
-        """Move to the start of the flyscan."""
+        """Move to the start of the fly scan."""
 
     @abstractmethod
     async def kickoff(self):
-        """Start the flyscan."""
+        """Start the fly scan."""
 
     @abstractmethod
     async def complete(self):
-        """Block until the flyscan is done."""
+        """Block until the fly scan is done."""
 
     @abstractmethod
     async def stop(self):
@@ -101,7 +101,7 @@ class StandardFlyer(
         return AsyncStatus(self._prepare(value))
 
     async def _prepare(self, value: T) -> None:
-        # Move to start and setup the flyscan
+        # Move to start and setup the fly scan
         await self._trigger_logic.prepare(value)
 
     @AsyncStatus.wrap

ophyd_async/core/_hdf_dataset.py

@@ -1,6 +1,4 @@
 from collections.abc import Iterator
-from pathlib import Path
-from urllib.parse import urlunparse
 
 from bluesky.protocols import StreamAsset
 from event_model import (  # type: ignore
@@ -48,22 +46,11 @@ class HDFDocumentComposer:
 
     def __init__(
         self,
-        full_file_name: Path,
+        file_uri: str,
         datasets: list[HDFDatasetDescription],
-        hostname: str = "localhost",
     ) -> None:
         self._last_emitted = 0
-        self._hostname = hostname
-        uri = urlunparse(
-            (
-                "file",
-                self._hostname,
-                str(full_file_name.absolute()),
-                "",
-                "",
-                None,
-            )
-        )
+        uri = file_uri
         bundler_composer = ComposeStreamResource()
         self._bundles: list[ComposeStreamResourceBundle] = [
             bundler_composer(

ophyd_async/core/_providers.py

@@ -1,11 +1,11 @@
-import os
 import uuid
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import date
-from pathlib import Path
+from pathlib import PurePath, PureWindowsPath
 from typing import Protocol
+from urllib.parse import urlunparse
 
 
 @dataclass
@@ -16,11 +16,36 @@ class PathInfo:
     :param filename: Base filename to use generated by FilenameProvider, w/o extension
     :param create_dir_depth: Optional depth of directories to create if they do not
                              exist
+    :param directory_uri: Optional URI to use for reading back resources. If not set,
+                          it will be generated from the directory path.
     """
 
-    directory_path: Path
+    directory_path: PurePath
     filename: str
     create_dir_depth: int = 0
+    directory_uri: str | None = None
+
+    def __post_init__(self):
+        if not self.directory_path.is_absolute():
+            raise ValueError(
+                f"directory_path must be an absolute path, got {self.directory_path}"
+            )
+
+        # If directory uri is not set, set it using the directory path.
+        if self.directory_uri is None:
+            self.directory_uri = urlunparse(
+                (
+                    "file",
+                    "localhost",
+                    f"{self.directory_path.as_posix()}/",
+                    "",
+                    "",
+                    None,
+                )
+            )
+        elif not self.directory_uri.endswith("/"):
+            # Ensure the directory URI ends with a slash.
+            self.directory_uri += "/"
 
 
 class FilenameProvider(Protocol):
@@ -112,11 +137,13 @@ class StaticPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        directory_path: Path | str,
+        directory_path: PurePath,
+        directory_uri: str | None = None,
         create_dir_depth: int = 0,
     ) -> None:
         self._filename_provider = filename_provider
-        self._directory_path = Path(directory_path)
+        self._directory_path = directory_path
+        self._directory_uri = directory_uri
         self._create_dir_depth = create_dir_depth
 
     def __call__(self, device_name: str | None = None) -> PathInfo:
@@ -124,6 +151,7 @@ class StaticPathProvider(PathProvider):
 
         return PathInfo(
             directory_path=self._directory_path,
+            directory_uri=self._directory_uri,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -135,7 +163,8 @@ class AutoIncrementingPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        base_directory_path: Path,
+        base_directory_path: PurePath,
+        base_directory_uri: str | None = None,
         create_dir_depth: int = 0,
         max_digits: int = 5,
         starting_value: int = 0,
@@ -146,6 +175,12 @@ class AutoIncrementingPathProvider(PathProvider):
     ) -> None:
         self._filename_provider = filename_provider
         self._base_directory_path = base_directory_path
+        self._base_directory_uri = base_directory_uri
+        if (
+            self._base_directory_uri is not None
+            and not self._base_directory_uri.endswith("/")
+        ):
+            self._base_directory_uri += "/"
         self._create_dir_depth = create_dir_depth
         self._base_name = base_name
         self._starting_value = starting_value
@@ -174,8 +209,13 @@ class AutoIncrementingPathProvider(PathProvider):
             self._inc_counter = 0
             self._current_value += self._increment
 
+        directory_uri = None
+        if self._base_directory_uri is not None:
+            directory_uri = f"{self._base_directory_uri}{auto_inc_dir_name}"
+
         return PathInfo(
             directory_path=self._base_directory_path / auto_inc_dir_name,
+            directory_uri=directory_uri,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -187,34 +227,52 @@ class YMDPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        base_directory_path: Path,
+        base_directory_path: PurePath,
+        base_directory_uri: str | None = None,
         create_dir_depth: int = -3,  # Default to -3 to create YMD dirs
         device_name_as_base_dir: bool = False,
     ) -> None:
         self._filename_provider = filename_provider
-        self._base_directory_path = Path(base_directory_path)
+        self._base_directory_path = base_directory_path
+        self._base_directory_uri = base_directory_uri
+        if (
+            self._base_directory_uri is not None
+            and not self._base_directory_uri.endswith("/")
+        ):
+            self._base_directory_uri += "/"
         self._create_dir_depth = create_dir_depth
         self._device_name_as_base_dir = device_name_as_base_dir
 
     def __call__(self, device_name: str | None = None) -> PathInfo:
-        sep = os.path.sep
+        path_type = type(self._base_directory_path)
+        if path_type == PureWindowsPath:
+            sep = "\\"
+        else:
+            sep = "/"
+
         current_date = date.today().strftime(f"%Y{sep}%m{sep}%d")
         if device_name is None:
             ymd_dir_path = current_date
         elif self._device_name_as_base_dir:
-            ymd_dir_path = os.path.join(
+            ymd_dir_path = path_type(
                 current_date,
                 device_name,
             )
         else:
-            ymd_dir_path = os.path.join(
+            ymd_dir_path = path_type(
                 device_name,
                 current_date,
             )
 
         filename = self._filename_provider(device_name)
+
+        directory_uri = None
+        if self._base_directory_uri is not None:
+            directory_uri = f"{self._base_directory_uri}{ymd_dir_path}"
+
         return PathInfo(
             directory_path=self._base_directory_path / ymd_dir_path,
+            directory_uri=directory_uri,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )

ophyd_async/core/_signal.py

@@ -17,6 +17,7 @@ from bluesky.protocols import (
     Subscribable,
 )
 from event_model import DataKey
+from stamina import retry_context
 
 from ._device import Device, DeviceConnector
 from ._mock_signal_backend import MockSignalBackend
@@ -89,9 +90,11 @@ class Signal(Device, Generic[SignalDatatypeT]):
         backend: SignalBackend[SignalDatatypeT],
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
+        attempts: int = 1,
     ) -> None:
         super().__init__(name=name, connector=SignalConnector(backend))
         self._timeout = timeout
+        self._attempts = attempts
 
     @property
     def source(self) -> str:
@@ -144,7 +147,8 @@ class _SignalCache(Generic[SignalDatatypeT]):
         )
         self._reading = reading
         self._valid.set()
-        for function, want_value in self._listeners.items():
+        items = self._listeners.copy().items()
+        for function, want_value in items:
             self._notify(function, want_value)
 
     def _notify(
@@ -287,7 +291,16 @@ class SignalW(Signal[SignalDatatypeT], Movable):
             timeout = self._timeout
         source = self._connector.backend.source(self.name, read=False)
         self.log.debug(f"Putting value {value} to backend at source {source}")
-        await _wait_for(self._connector.backend.put(value, wait=wait), timeout, source)
+        async for attempt in retry_context(
+            on=asyncio.TimeoutError,
+            attempts=self._attempts,
+            wait_initial=0,
+            wait_jitter=0,
+        ):
+            with attempt:
+                await _wait_for(
+                    self._connector.backend.put(value, wait=wait), timeout, source
+                )
         self.log.debug(f"Successfully put value {value} to backend at source {source}")
 
 

ophyd_async/core/_soft_signal_backend.py

@@ -148,7 +148,7 @@ class SoftSignalBackend(SignalBackend[SignalDatatypeT]):
         """Set the current value, alarm and timestamp."""
         self.reading = Reading(
             value=self.converter.write_value(value),
-            timestamp=time.monotonic(),
+            timestamp=time.time(),
             alarm_severity=0,
         )
         if self.callback:

ophyd_async/epics/adcore/__init__.py

@@ -14,6 +14,7 @@ from ._core_io import (
     NDCBFlushOnSoftTrgMode,
     NDFileHDFIO,
     NDFileIO,
+    NDFilePluginIO,
     NDPluginBaseIO,
     NDPluginCBIO,
     NDPluginStatsIO,
@@ -45,6 +46,7 @@ __all__ = [
     "ContAcqAreaDetector",
     "NDArrayBaseIO",
     "NDFileIO",
+    "NDFilePluginIO",
     "NDFileHDFIO",
     "NDPluginBaseIO",
     "NDPluginStatsIO",

ophyd_async/epics/adcore/_core_io.py

@@ -131,11 +131,11 @@ class ADCompression(StrictEnum):
     JPEG = "JPEG"
 
 
-class NDFileIO(NDPluginBaseIO):
-    """Base class from which file plugins are derived.
+class NDFileIO(NDArrayBaseIO):
+    """Base class from which file writing drivers are derived.
 
-    This mirrors the interface provided by ADCore/db/NDFile.template.
-    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginFile.html
+    This mirrors the interface provided by ADCore/ADApp/Db/NDFile.template.
+    It does not include any plugin-related fields, for that see NDFilePluginIO.
     """
 
     file_path: A[SignalRW[str], PvSuffix.rbv("FilePath")]
@@ -154,7 +154,17 @@ class NDFileIO(NDPluginBaseIO):
     create_directory: A[SignalRW[int], PvSuffix("CreateDirectory")]
 
 
-class NDFileHDFIO(NDFileIO):
+class NDFilePluginIO(NDPluginBaseIO, NDFileIO):
+    """Base class from which file plugins are derived.
+
+    This mirrors the interface provided by ADCore/db/NDFilePlugin.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginFile.html
+    """
+
+    ...
+
+
+class NDFileHDFIO(NDFilePluginIO):
     """Plugin for storing data in HDF5 file format.
 
     This mirrors the interface provided by ADCore/db/NDFileHDF5.template.

ophyd_async/epics/adcore/_core_writer.py

@@ -1,8 +1,7 @@
 import asyncio
 from collections.abc import AsyncGenerator, AsyncIterator
-from pathlib import Path
+from pathlib import PureWindowsPath
 from typing import Generic, TypeVar, get_args
-from urllib.parse import urlunparse
 
 from bluesky.protocols import Hints, StreamAsset
 from event_model import (  # type: ignore
@@ -13,14 +12,14 @@ from event_model import (  # type: ignore
 from pydantic import PositiveInt
 
 from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._providers import DatasetDescriber, PathProvider
+from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
     set_and_wait_for_value,
     wait_for_value,
 )
 from ophyd_async.core._status import AsyncStatus
-from ophyd_async.core._utils import DEFAULT_TIMEOUT
+from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
@@ -28,6 +27,7 @@ from ._core_io import (
     ADCallbacks,
     NDArrayBaseIO,
     NDFileIO,
+    NDFilePluginIO,
     NDPluginBaseIO,
 )
 from ._utils import ADFileWriteMode
@@ -52,7 +52,8 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
     ) -> None:
         self._plugins = plugins or {}
         self.fileio = fileio
-        self._path_provider = path_provider
+        self._path_provider: PathProvider = path_provider
+        self._path_info: PathInfo | None = None
         self._dataset_describer = dataset_describer
         self._file_extension = file_extension
         self._mimetype = mimetype
@@ -82,19 +83,32 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         writer = cls(fileio, path_provider, dataset_describer, plugins=plugins)
         return writer
 
-    async def begin_capture(self, name: str) -> None:
-        info = self._path_provider(device_name=name)
+    async def _begin_capture(self, name: str) -> None:
+        path_info = error_if_none(
+            self._path_info, "Writer must be opened before beginning capture!"
+        )
 
-        await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
+        if isinstance(self.fileio, NDFilePluginIO):
+            await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.
-        await self.fileio.create_directory.set(info.create_dir_depth)
+        await self.fileio.create_directory.set(path_info.create_dir_depth)
+
+        # Need to ensure that trailing separator is added to the directory path.
+        # When setting the path for windows based AD IOCs, a '/' is added rather than
+        # a '\\', which will cause the readback to never register the same value.
+        dir_path_as_str = str(path_info.directory_path)
+        separator = "/"
+        if isinstance(path_info.directory_path, PureWindowsPath):
+            separator = "\\"
+
+        dir_path_as_str += separator
 
         await asyncio.gather(
             # See https://github.com/bluesky/ophyd-async/issues/122
-            self.fileio.file_path.set(str(info.directory_path)),
-            self.fileio.file_name.set(info.filename),
+            self.fileio.file_path.set(dir_path_as_str),
+            self.fileio.file_name.set(path_info.filename),
             self.fileio.file_write_mode.set(ADFileWriteMode.STREAM),
             # For non-HDF file writers, use AD file templating mechanism
             # for generating multi-image datasets
@@ -106,7 +120,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         )
 
         if not await self.fileio.file_path_exists.get_value():
-            msg = f"File path {info.directory_path} for file plugin does not exist"
+            msg = f"Path {dir_path_as_str} doesn't exist or not writable!"
             raise FileNotFoundError(msg)
 
         # Overwrite num_capture to go forever
@@ -125,7 +139,9 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         frame_shape = await self._dataset_describer.shape()
         dtype_numpy = await self._dataset_describer.np_datatype()
 
-        await self.begin_capture(name)
+        self._path_info = self._path_provider(device_name=name)
+
+        await self._begin_capture(name)
 
         describe = {
             name: DataKey(
@@ -152,30 +168,22 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
     async def collect_stream_docs(
         self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
+        path_info = error_if_none(
+            self._path_info, "Writer must be opened before collecting stream docs!"
+        )
+
         if indices_written:
             if not self._emitted_resource:
-                file_path = Path(await self.fileio.file_path.get_value())
                 file_name = await self.fileio.file_name.get_value()
                 file_template = file_name + "_{:06d}" + self._file_extension
 
                 frame_shape = await self._dataset_describer.shape()
 
-                uri = urlunparse(
-                    (
-                        "file",
-                        "localhost",
-                        str(file_path.absolute()) + "/",
-                        "",
-                        "",
-                        None,
-                    )
-                )
-
                 bundler_composer = ComposeStreamResource()
 
                 self._emitted_resource = bundler_composer(
                     mimetype=self._mimetype,
-                    uri=uri,
+                    uri=str(path_info.directory_uri),
                     # TODO no reference to detector's name
                     data_key=name,
                     parameters={

ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,6 +1,5 @@
 import asyncio
 from collections.abc import AsyncIterator
-from pathlib import Path
 from typing import TypeGuard
 from xml.etree import ElementTree as ET
 
@@ -65,8 +64,10 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             self.fileio.xml_file_name.set(""),
         )
 
+        self._path_info = self._path_provider(device_name=name)
+
         # Set common AD file plugin params, begin capturing
-        await self.begin_capture(name)
+        await self._begin_capture(name)
 
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()
@@ -100,7 +101,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
 
         self._composer = HDFDocumentComposer(
             # See https://github.com/bluesky/ophyd-async/issues/122
-            Path(await self.fileio.full_file_name.get_value()),
+            f"{self._path_info.directory_uri}{self._path_info.filename}{self._file_extension}",
             self._datasets,
         )
 

ophyd_async/epics/adcore/_jpeg_writer.py

@@ -1,15 +1,15 @@
 from ophyd_async.core import DatasetDescriber, PathProvider
 
-from ._core_io import NDFileIO, NDPluginBaseIO
+from ._core_io import NDFilePluginIO, NDPluginBaseIO
 from ._core_writer import ADWriter
 
 
-class ADJPEGWriter(ADWriter[NDFileIO]):
+class ADJPEGWriter(ADWriter[NDFilePluginIO]):
     default_suffix: str = "JPEG1:"
 
     def __init__(
         self,
-        fileio: NDFileIO,
+        fileio: NDFilePluginIO,
         path_provider: PathProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,

ophyd_async/epics/adcore/_tiff_writer.py

@@ -1,15 +1,15 @@
 from ophyd_async.core import DatasetDescriber, PathProvider
 
-from ._core_io import NDFileIO, NDPluginBaseIO
+from ._core_io import NDFilePluginIO, NDPluginBaseIO
 from ._core_writer import ADWriter
 
 
-class ADTIFFWriter(ADWriter[NDFileIO]):
+class ADTIFFWriter(ADWriter[NDFilePluginIO]):
     default_suffix: str = "TIFF1:"
 
     def __init__(
         self,
-        fileio: NDFileIO,
+        fileio: NDFilePluginIO,
         path_provider: PathProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,

ophyd_async/epics/core/_aioca.py

@@ -250,10 +250,12 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
+        all_updates: bool = True,
     ):
         self.converter: CaConverter = DisconnectedCaConverter(float, dbr.DBR_DOUBLE)
         self.initial_values: dict[str, AugmentedValue] = {}
         self.subscription: Subscription | None = None
+        self._all_updates = all_updates
         super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):
@@ -356,4 +358,5 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
                 lambda v: callback(self._make_reading(v)),
                 datatype=self.converter.read_dbr,
                 format=FORMAT_TIME,
+                all_updates=self._all_updates,
             )

ophyd_async/epics/core/_signal.py

@@ -94,6 +94,7 @@ def epics_signal_rw(
     write_pv: str | None = None,
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs.
 
@@ -104,7 +105,7 @@ def epics_signal_rw(
     :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
-    return SignalRW(backend, name=name, timeout=timeout)
+    return SignalRW(backend, name=name, timeout=timeout, attempts=attempts)
 
 
 def epics_signal_rw_rbv(
@@ -113,6 +114,7 @@ def epics_signal_rw_rbv(
     read_suffix: str = "_RBV",
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv.
 
@@ -128,7 +130,9 @@ def epics_signal_rw_rbv(
     else:
         read_pv = f"{write_pv}{read_suffix}"
 
-    return epics_signal_rw(datatype, read_pv, write_pv, name, timeout=timeout)
+    return epics_signal_rw(
+        datatype, read_pv, write_pv, name, timeout=timeout, attempts=attempts
+    )
 
 
 def epics_signal_r(
@@ -153,6 +157,7 @@ def epics_signal_w(
     write_pv: str,
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalW[SignalDatatypeT]:
     """Create a `SignalW` backed by 1 EPICS PVs.
 
@@ -162,7 +167,7 @@ def epics_signal_w(
     :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, write_pv, write_pv)
-    return SignalW(backend, name=name, timeout=timeout)
+    return SignalW(backend, name=name, timeout=timeout, attempts=attempts)
 
 
 def epics_signal_x(

ophyd_async/epics/motor.py

@@ -108,7 +108,7 @@ class Motor(
 
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
-        """Move to the beginning of a suitable run-up distance ready for a flyscan."""
+        """Move to the beginning of a suitable run-up distance ready for a fly scan."""
         self._fly_info = value
 
         # Velocity, at which motor travels from start_position to end_position, in motor
@@ -147,7 +147,7 @@ class Motor(
         await self.velocity.set(abs(max_speed))
         await self.set(ramp_up_start_pos)
 
-        # Set velocity we will be using for the flyscan
+        # Set velocity we will be using for the fly scan
         await self.velocity.set(abs(value.velocity))
 
     @AsyncStatus.wrap

ophyd_async/epics/testing/_utils.py

@@ -40,7 +40,7 @@ class TestingIOC:
         assert self._process.stdout  # noqa: S101 # this is to make Pylance happy
         start_time = time.monotonic()
         while "iocRun: All initialization complete" not in self.output:
-            if time.monotonic() - start_time > 10:
+            if time.monotonic() - start_time > 15:
                 self.stop()
                 raise TimeoutError(f"IOC did not start in time:\n{self.output}")
             self.output += self._process.stdout.readline()