ophyd-async 0.5.0__tar.gz → 0.5.2__tar.gz

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/.github/workflows/_release.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Create GitHub Release
         # We pin to the SHA, not the tag, for security reasons.
         # https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions
-        uses: softprops/action-gh-release@a74c6b72af54cfa997e81df42d94703d6313a2d0 # v2.0.6
+        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191 # v2.0.8
         with:
           prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}
           files: "*"

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.5.0
+Version: 0.5.2
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -55,14 +55,16 @@ Provides-Extra: ca
 Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p; extra == "pva"
+Provides-Extra: sim
+Requires-Dist: h5py; extra == "sim"
 Provides-Extra: dev
 Requires-Dist: ophyd_async[pva]; extra == "dev"
+Requires-Dist: ophyd_async[sim]; extra == "dev"
 Requires-Dist: ophyd_async[ca]; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: flake8-isort; extra == "dev"
 Requires-Dist: Flake8-pyproject; extra == "dev"
-Requires-Dist: h5py; extra == "dev"
 Requires-Dist: inflection; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
 Requires-Dist: ipywidgets; extra == "dev"

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/docs/examples/foo_detector.py

@@ -69,7 +69,7 @@ class FooDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/docs/how-to/make-a-simple-device.rst

@@ -29,7 +29,7 @@ First some Signals are constructed and stored on the Device. Each one is passed
 its Python type, which could be:
 
 - A primitive (`str`, `int`, `float`)
-- An array (`numpy.typing.NDArray` or ``Sequence[str]``)
+- An array (`numpy.typing.NDArray` ie. ``numpy.typing.NDArray[numpy.uint16]`` or ``Sequence[str]``)
 - An enum (`enum.Enum`) which **must** also extend `str`
     - `str` and ``EnumClass(str, Enum)`` are the only valid ``datatype`` for an enumerated signal.
 

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/docs/how-to/make-a-standard-detector.rst

@@ -50,12 +50,12 @@ Writing a non-AreaDetector StandardDetector
 A non-AreaDetector `StandardDetector` should implement `DetectorControl` and `DetectorWriter` directly.
 Here we construct a `DetectorControl` that co-ordinates signals on a PandA PositionCapture block - a child device "pcap" of the `StandardDetector` implementation, analogous to the :py:class:`FooDriver`.
 
-.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_panda_controller.py
+.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_control.py
    :pyobject: PandaPcapController
 
 The PandA may write a number of fields, and the :py:class:`PandaHDFWriter` co-ordinates those, configures the filewriter and describes the data for the RunEngine.
 
-.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_hdf_writer.py
+.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_writer.py
    :pyobject: PandaHDFWriter
 
 The PandA StandardDetector implementation simply ties the component parts and its child devices together.

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/pyproject.toml

@@ -32,14 +32,15 @@ requires-python = ">=3.10"
 [project.optional-dependencies]
 ca = ["aioca>=1.6"]
 pva = ["p4p"]
+sim = ["h5py"]
 dev = [
     "ophyd_async[pva]",
+    "ophyd_async[sim]",
     "ophyd_async[ca]",
     "black",
     "flake8",
     "flake8-isort",
     "Flake8-pyproject",
-    "h5py",
     "inflection",
     "ipython",
     "ipywidgets",
@@ -138,7 +139,7 @@ commands =
 
 
 [tool.ruff]
-src = ["src", "tests"]
+src = ["src", "tests", "system_tests"]
 line-length = 88
 lint.select = [
     "C4",   # flake8-comprehensions - https://beta.ruff.rs/docs/rules/#flake8-comprehensions-c4
@@ -146,4 +147,11 @@ lint.select = [
     "F",    # pyflakes rules - https://beta.ruff.rs/docs/rules/#pyflakes-f
     "W",    # pycodestyle warnings - https://beta.ruff.rs/docs/rules/#warning-w
     "I001", # isort
+    "SLF",  # self - https://docs.astral.sh/ruff/settings/#lintflake8-self
 ]
+
+[tool.ruff.lint.per-file-ignores]
+# By default, private member access is allowed in tests
+# See https://github.com/DiamondLightSource/python-copier-template/issues/154
+# Remove this line to forbid private member access in tests
+"tests/**/*" = ["SLF001"]

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/core/__init__.py

@@ -33,11 +33,11 @@ from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
 from ._providers import (
     AutoIncrementFilenameProvider,
     AutoIncrementingPathProvider,
+    DatasetDescriber,
     FilenameProvider,
     NameProvider,
     PathInfo,
     PathProvider,
-    ShapeProvider,
     StaticFilenameProvider,
     StaticPathProvider,
     UUIDFilenameProvider,
@@ -55,6 +55,7 @@ from ._signal import (
     assert_reading,
     assert_value,
     observe_value,
+    set_and_wait_for_other_value,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
@@ -62,7 +63,7 @@ from ._signal import (
 )
 from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
 from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
-from ._status import AsyncStatus, WatchableAsyncStatus
+from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
 from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
@@ -116,7 +117,7 @@ __all__ = [
     "NameProvider",
     "PathInfo",
     "PathProvider",
-    "ShapeProvider",
+    "DatasetDescriber",
     "StaticFilenameProvider",
     "StaticPathProvider",
     "UUIDFilenameProvider",
@@ -135,6 +136,7 @@ __all__ = [
     "assert_value",
     "observe_value",
     "set_and_wait_for_value",
+    "set_and_wait_for_other_value",
     "soft_signal_r_and_setter",
     "soft_signal_rw",
     "wait_for_value",
@@ -156,4 +158,5 @@ __all__ = [
     "get_unique",
     "in_micros",
     "wait_for_connection",
+    "completed_status",
 ]

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/core/_detector.py

@@ -55,11 +55,16 @@ class TriggerInfo(BaseModel):
     #: Sort of triggers that will be sent
     trigger: DetectorTrigger = Field()
     #: What is the minimum deadtime between triggers
-    deadtime: float = Field(ge=0)
+    deadtime: float | None = Field(ge=0)
     #: What is the maximum high time of the triggers
-    livetime: float = Field(ge=0)
+    livetime: float | None = Field(ge=0)
     #: What is the maximum timeout on waiting for a frame
     frame_timeout: float | None = Field(None, gt=0)
+    #: How many triggers make up a single StreamDatum index, to allow multiple frames
+    #: from a faster detector to be zipped with a single frame from a slow detector
+    #: e.g. if num=10 and multiplier=5 then the detector will take 10 frames,
+    #: but publish 2 indices, and describe() will show a shape of (5, h, w)
+    multiplier: int = 1
 
 
 class DetectorControl(ABC):
@@ -69,7 +74,7 @@ class DetectorControl(ABC):
     """
 
     @abstractmethod
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         """For a given exposure, how long should the time between exposures be"""
 
     @abstractmethod
@@ -196,10 +201,10 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        # Disarm the detector, stop filewriting, and open file for writing.
+        # Disarm the detector, stop filewriting.
         await self._check_config_sigs()
         await asyncio.gather(self.writer.close(), self.controller.disarm())
-        self._describe = await self.writer.open()
+        self._trigger_info = None
 
     async def _check_config_sigs(self):
         """Checks configuration signals are named and connected."""
@@ -212,7 +217,7 @@ class StandardDetector(
                 await signal.get_value()
             except NotImplementedError:
                 raise Exception(
-                    f"config signal {signal._name} must be connected before it is "
+                    f"config signal {signal.name} must be connected before it is "
                     + "passed to the detector"
                 )
 
@@ -236,10 +241,15 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
-        # set default trigger_info
-        self._trigger_info = TriggerInfo(
-            number=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
-        )
+        if self._trigger_info is None:
+            await self.prepare(
+                TriggerInfo(
+                    number=1,
+                    trigger=DetectorTrigger.internal,
+                    deadtime=None,
+                    livetime=None,
+                )
+            )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
@@ -250,19 +260,15 @@ class StandardDetector(
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
+            DEFAULT_TIMEOUT
+            + (self._trigger_info.livetime or 0)
+            + (self._trigger_info.deadtime or 0)
         ):
             if index >= end_observation:
                 break
 
-    def prepare(
-        self,
-        value: T,
-    ) -> AsyncStatus:
-        # Just arm detector for the time being
-        return AsyncStatus(self._prepare(value))
-
-    async def _prepare(self, value: T) -> None:
+    @AsyncStatus.wrap
+    async def prepare(self, value: TriggerInfo) -> None:
         """
         Arm detector.
 
@@ -277,22 +283,26 @@ class StandardDetector(
         Args:
             value: TriggerInfo describing how to trigger the detector
         """
-        assert type(value) is TriggerInfo
         self._trigger_info = value
+        if value.trigger != DetectorTrigger.internal:
+            assert (
+                value.deadtime
+            ), "Deadtime must be supplied when in externally triggered mode"
+        if value.deadtime:
+            required = self.controller.get_deadtime(self._trigger_info.livetime)
+            assert required <= value.deadtime, (
+                f"Detector {self.controller} needs at least {required}s deadtime, "
+                f"but trigger logic provides only {value.deadtime}s"
+            )
         self._initial_frame = await self.writer.get_indices_written()
         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, (
-            f"Detector {self.controller} needs at least {required}s deadtime, "
-            f"but trigger logic provides only {self._trigger_info.deadtime}s"
-        )
         self._arm_status = await self.controller.arm(
             num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
             exposure=self._trigger_info.livetime,
         )
         self._fly_start = time.monotonic()
+        self._describe = await self.writer.open(value.multiplier)
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -307,8 +317,8 @@ class StandardDetector(
             self._trigger_info.frame_timeout
             or (
                 DEFAULT_TIMEOUT
-                + self._trigger_info.livetime
-                + self._trigger_info.deadtime
+                + (self._trigger_info.livetime or 0)
+                + (self._trigger_info.deadtime or 0)
             )
         ):
             yield WatcherUpdate(

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/core/_hdf_dataset.py

@@ -10,8 +10,6 @@ from event_model import (
     StreamResource,
 )
 
-from ._providers import PathInfo
-
 
 @dataclass
 class HDFDataset:
@@ -28,14 +26,12 @@ 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",
@@ -53,7 +49,7 @@ class HDFFile:
             (
                 "file",
                 self._hostname,
-                str((path_info.root / full_file_name).absolute()),
+                str(full_file_name.absolute()),
                 "",
                 "",
                 None,

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/core/_mock_signal_utils.py

@@ -8,11 +8,12 @@ from ._utils import T
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
-    assert isinstance(signal._backend, MockSignalBackend), (
+    backend = signal._backend  # noqa:SLF001
+    assert isinstance(backend, MockSignalBackend), (
         "Expected to receive a `MockSignalBackend`, instead "
-        f" received {type(signal._backend)}. "
+        f" received {type(backend)}. "
     )
-    return signal._backend
+    return backend
 
 
 def set_mock_value(signal: Signal[T], value: T):

{ophyd_async-0.5.0 → ophyd_async-0.5.2}/src/ophyd_async/core/_providers.py

@@ -13,34 +13,24 @@ class PathInfo:
     """
     Information about where and how to write a file.
 
-    The bluesky event model splits the URI for a resource into two segments to aid in
-    different applications mounting filesystems at different mount points.
-    The portion of this path which is relevant only for the writer is the 'root',
-    while the path from an agreed upon mutual mounting is the resource_path.
-    The resource_dir is used with the filename to construct the resource_path.
-
-    :param root: Path of a root directory, relevant only for the file writer
-    :param resource_dir: Directory into which files should be written, relative to root
+    :param directory_path: Directory into which files should be written
     :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
     """
 
-    root: Path
-    resource_dir: Path
+    directory_path: Path
     filename: str
     create_dir_depth: int = 0
 
 
 class FilenameProvider(Protocol):
     @abstractmethod
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         """Get a filename to use for output data, w/o extension"""
 
 
 class PathProvider(Protocol):
-    _filename_provider: FilenameProvider
-
     @abstractmethod
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
         """Get the current directory to write files into"""
@@ -50,7 +40,7 @@ class StaticFilenameProvider(FilenameProvider):
     def __init__(self, filename: str):
         self._static_filename = filename
 
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         return self._static_filename
 
 
@@ -63,7 +53,7 @@ class UUIDFilenameProvider(FilenameProvider):
         self._uuid_call_func = uuid_call_func
         self._uuid_call_args = uuid_call_args or []
 
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         if (
             self._uuid_call_func in [uuid.uuid3, uuid.uuid5]
             and len(self._uuid_call_args) < 2
@@ -92,7 +82,7 @@ class AutoIncrementFilenameProvider(FilenameProvider):
         self._increment = increment
         self._inc_delimeter = inc_delimeter
 
-    def __call__(self):
+    def __call__(self, device_name: Optional[str] = None) -> str:
         if len(str(self._current_value)) > self._max_digits:
             raise ValueError(
                 f"Auto incrementing filename counter \
@@ -112,20 +102,17 @@ class StaticPathProvider(PathProvider):
         self,
         filename_provider: FilenameProvider,
         directory_path: Path,
-        resource_dir: Path = Path("."),
         create_dir_depth: int = 0,
     ) -> None:
         self._filename_provider = filename_provider
         self._directory_path = directory_path
-        self._resource_dir = resource_dir
         self._create_dir_depth = create_dir_depth
 
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
 
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=self._resource_dir,
+            directory_path=self._directory_path,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -135,7 +122,7 @@ class AutoIncrementingPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        directory_path: Path,
+        base_directory_path: Path,
         create_dir_depth: int = 0,
         max_digits: int = 5,
         starting_value: int = 0,
@@ -145,7 +132,7 @@ class AutoIncrementingPathProvider(PathProvider):
         base_name: str = None,
     ) -> None:
         self._filename_provider = filename_provider
-        self._directory_path = directory_path
+        self._base_directory_path = base_directory_path
         self._create_dir_depth = create_dir_depth
         self._base_name = base_name
         self._starting_value = starting_value
@@ -157,15 +144,17 @@ class AutoIncrementingPathProvider(PathProvider):
         self._inc_delimeter = inc_delimeter
 
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
 
         padded_counter = f"{self._current_value:0{self._max_digits}}"
 
-        resource_dir = str(padded_counter)
+        auto_inc_dir_name = str(padded_counter)
         if self._base_name is not None:
-            resource_dir = f"{self._base_name}{self._inc_delimeter}{padded_counter}"
+            auto_inc_dir_name = (
+                f"{self._base_name}{self._inc_delimeter}{padded_counter}"
+            )
         elif device_name is not None:
-            resource_dir = f"{device_name}{self._inc_delimeter}{padded_counter}"
+            auto_inc_dir_name = f"{device_name}{self._inc_delimeter}{padded_counter}"
 
         self._inc_counter += 1
         if self._inc_counter == self._num_calls_per_inc:
@@ -173,8 +162,7 @@ class AutoIncrementingPathProvider(PathProvider):
             self._current_value += self._increment
 
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=resource_dir,
+            directory_path=self._base_directory_path / auto_inc_dir_name,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -184,12 +172,12 @@ class YMDPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        directory_path: Path,
+        base_directory_path: Path,
         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._directory_path = Path(directory_path)
+        self._base_directory_path = Path(base_directory_path)
         self._create_dir_depth = create_dir_depth
         self._device_name_as_base_dir = device_name_as_base_dir
 
@@ -197,22 +185,21 @@ class YMDPathProvider(PathProvider):
         sep = os.path.sep
         current_date = date.today().strftime(f"%Y{sep}%m{sep}%d")
         if device_name is None:
-            resource_dir = current_date
+            ymd_dir_path = current_date
         elif self._device_name_as_base_dir:
-            resource_dir = os.path.join(
+            ymd_dir_path = os.path.join(
                 current_date,
                 device_name,
             )
         else:
-            resource_dir = os.path.join(
+            ymd_dir_path = os.path.join(
                 device_name,
                 current_date,
             )
 
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=resource_dir,
+            directory_path=self._base_directory_path / ymd_dir_path,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -224,7 +211,11 @@ class NameProvider(Protocol):
         """Get the name to be used as a data_key in the descriptor document"""
 
 
-class ShapeProvider(Protocol):
+class DatasetDescriber(Protocol):
+    @abstractmethod
+    async def np_datatype(self) -> str:
+        """Represents the numpy datatype"""
+
     @abstractmethod
-    async def __call__(self) -> tuple:
+    async def shape(self) -> tuple[int, ...]:
         """Get the shape of the data collection"""