ophyd-async 0.1.0__tar.gz → 0.3a1__tar.gz

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/.codecov.yml

@@ -5,7 +5,7 @@ coverage:
     project:
       default:
         target: auto
-        threshold: 0.1%
+        threshold: 1%
     patch:
       default:
         target: auto

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/.github/actions/install_requirements/action.yml

@@ -9,7 +9,7 @@ inputs:
     required: true
   python_version:
     description: Python version to install
-    default: "3.x"
+    default: "3.9"
 
 runs:
   using: composite

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/.github/workflows/code.yml

@@ -109,6 +109,9 @@ jobs:
     needs: [lint, dist, test]
     if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags') }}
     runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
     env:
       HAS_PYPI_TOKEN: ${{ secrets.PYPI_TOKEN != '' }}
 
@@ -132,8 +135,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Publish to PyPI
-        if: ${{ env.HAS_PYPI_TOKEN }}
+      - name: Publish wheels to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          password: ${{ secrets.PYPI_TOKEN }}
+          packages-dir: ./dist/

{ophyd-async-0.1.0/src/ophyd_async.egg-info → ophyd-async-0.3a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.1.0
+Version: 0.3a1
 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
@@ -46,9 +46,10 @@ Requires-Dist: networkx>=2.0
 Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: bluesky
+Requires-Dist: bluesky>=1.13.0a3
 Requires-Dist: event-model
 Requires-Dist: p4p
+Requires-Dist: pyyaml
 Provides-Extra: ca
 Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
@@ -56,14 +57,7 @@ Requires-Dist: p4p; extra == "pva"
 Provides-Extra: dev
 Requires-Dist: ophyd_async[pva]; extra == "dev"
 Requires-Dist: ophyd_async[ca]; extra == "dev"
-Requires-Dist: attrs>=19.3.0; extra == "dev"
 Requires-Dist: black; extra == "dev"
-Requires-Dist: bluesky>=1.11.0; extra == "dev"
-Requires-Dist: caproto[standard]>=0.4.2rc1; extra == "dev"
-Requires-Dist: pytest-codecov; extra == "dev"
-Requires-Dist: databroker>=1.0.0b1; extra == "dev"
-Requires-Dist: doctr; extra == "dev"
-Requires-Dist: epics-pypdb; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: flake8-isort; extra == "dev"
 Requires-Dist: Flake8-pyproject; extra == "dev"
@@ -76,6 +70,7 @@ Requires-Dist: mypy; extra == "dev"
 Requires-Dist: myst-parser; extra == "dev"
 Requires-Dist: numpydoc; extra == "dev"
 Requires-Dist: ophyd; extra == "dev"
+Requires-Dist: pickleshare; extra == "dev"
 Requires-Dist: pipdeptree; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pydata-sphinx-theme>=0.12; extra == "dev"
@@ -92,53 +87,59 @@ Requires-Dist: sphinx-copybutton; extra == "dev"
 Requires-Dist: sphinx-design; extra == "dev"
 Requires-Dist: tox-direct; extra == "dev"
 Requires-Dist: types-mock; extra == "dev"
+Requires-Dist: types-pyyaml; extra == "dev"
 
-***********
 Ophyd Async
-***********
+===========
 
-|build_status| |coverage| |pypi_version| |license|
+|code_ci| |docs_ci| |coverage| |pypi_version| |license|
 
-Ophyd is a Python library for interfacing with hardware. It provides an
-abstraction layer that enables experiment orchestration and data acquisition
-code to operate above the specifics of particular devices and control systems.
+Asynchronous device abstraction framework, building on `Ophyd`_.
 
-Ophyd is typically used with the `Bluesky Run Engine`_ for experiment
-orchestration and data acquisition. It is also sometimes used in a stand-alone
-fashion.
+============== ==============================================================
+PyPI           ``pip install ophyd-async``
+Source code    https://github.com/bluesky/ophyd-async
+Documentation  https://blueskyproject.io/ophyd-async
+============== ==============================================================
 
-Many facilities use ophyd to integrate with control systems that use `EPICS`_ ,
-but ophyd's design and some of its objects are also used to integrate with
-other control systems.
+Python library for asynchronously interfacing with hardware, intended to 
+be used as an abstraction layer that enables experiment orchestration and data 
+acquisition code to operate above the specifics of particular devices and control
+systems.
 
-* Put the details specific to a device or control system behind a **high-level
-  interface** with methods like ``trigger()``, ``read()``, and ``set(...)``.
-* **Group** individual control channels (such as EPICS V3 PVs) into logical
-  "Devices" to be configured and used as units with internal coordination.
-* Assign readings with **names meaningful for data analysis** that will
-  propagate into metadata.
-* **Categorize** readings by "kind" (primary reading, configuration,
-  engineering/debugging) which can be read selectively.
+Both ophyd and ophyd-async are typically used with the `Bluesky Run Engine`_ for 
+experiment orchestration and data acquisition. However, these libraries are
+able to be used in a stand-alone fashion. For an example of how a facility defines
+and uses ophyd-async devices, see `dls-dodal`_, which is currently using a
+mixture of ophyd and ophyd-async devices.
 
-============== ==============================================================
-PyPI           ``pip install ophyd``
-Conda          ``conda install -c conda-forge ophyd``
-Source code    https://github.com/bluesky/ophyd
-Documentation  https://blueskyproject.io/ophyd
-============== ==============================================================
+While `EPICS`_ is the most common control system layer that ophyd-async can
+interface with, other control systems like `Tango`_ are used by some facilities
+also. In addition to the abstractions provided by ophyd, ophyd-async allows:
+
+* Asynchronous signal access, opening the possibility for hardware-triggered
+  scanning (also known as fly-scanning)
+* Simpler instantiation of devices (groupings of signals) with less reliance
+  upon complex class hierarchies
+
+NOTE: ophyd-async is included on a provisional basis until the v1.0 release.
 
 See the tutorials for usage examples.
 
-.. |build_status| image:: https://github.com/bluesky/ophyd/workflows/Unit%20Tests/badge.svg?branch=master
-    :target: https://github.com/bluesky/ophyd/actions?query=workflow%3A%22Unit+Tests%22
-    :alt: Build Status
+.. |code_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml/badge.svg?branch=main
+    :target: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml
+    :alt: Code CI
+
+.. |docs_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml/badge.svg?branch=main
+    :target: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml
+    :alt: Docs CI
 
-.. |coverage| image:: https://codecov.io/gh/bluesky/ophyd/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/bluesky/ophyd
+.. |coverage| image:: https://codecov.io/gh/bluesky/ophyd-async/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/bluesky/ophyd-async
     :alt: Test Coverage
 
-.. |pypi_version| image:: https://img.shields.io/pypi/v/ophyd.svg
-    :target: https://pypi.org/project/ophyd
+.. |pypi_version| image:: https://img.shields.io/pypi/v/ophyd-async.svg
+    :target: https://pypi.org/project/ophyd-async
     :alt: Latest PyPI version
 
 .. |license| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
@@ -147,8 +148,14 @@ See the tutorials for usage examples.
 
 .. _Bluesky Run Engine: http://blueskyproject.io/bluesky
 
+.. _Ophyd: http://blueskyproject.io/ophyd
+
+.. _dls-dodal: https://github.com/DiamondLightSource/dodal
+
 .. _EPICS: http://www.aps.anl.gov/epics/
 
+.. _Tango: https://www.tango-controls.org/
+
 ..
     Anything below this line is used when viewing README.rst and will be replaced
     when included in index.rst

ophyd-async-0.3a1/README.rst

@@ -0,0 +1,72 @@
+Ophyd Async
+===========
+
+|code_ci| |docs_ci| |coverage| |pypi_version| |license|
+
+Asynchronous device abstraction framework, building on `Ophyd`_.
+
+============== ==============================================================
+PyPI           ``pip install ophyd-async``
+Source code    https://github.com/bluesky/ophyd-async
+Documentation  https://blueskyproject.io/ophyd-async
+============== ==============================================================
+
+Python library for asynchronously interfacing with hardware, intended to 
+be used as an abstraction layer that enables experiment orchestration and data 
+acquisition code to operate above the specifics of particular devices and control
+systems.
+
+Both ophyd and ophyd-async are typically used with the `Bluesky Run Engine`_ for 
+experiment orchestration and data acquisition. However, these libraries are
+able to be used in a stand-alone fashion. For an example of how a facility defines
+and uses ophyd-async devices, see `dls-dodal`_, which is currently using a
+mixture of ophyd and ophyd-async devices.
+
+While `EPICS`_ is the most common control system layer that ophyd-async can
+interface with, other control systems like `Tango`_ are used by some facilities
+also. In addition to the abstractions provided by ophyd, ophyd-async allows:
+
+* Asynchronous signal access, opening the possibility for hardware-triggered
+  scanning (also known as fly-scanning)
+* Simpler instantiation of devices (groupings of signals) with less reliance
+  upon complex class hierarchies
+
+NOTE: ophyd-async is included on a provisional basis until the v1.0 release.
+
+See the tutorials for usage examples.
+
+.. |code_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml/badge.svg?branch=main
+    :target: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml
+    :alt: Code CI
+
+.. |docs_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml/badge.svg?branch=main
+    :target: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml
+    :alt: Docs CI
+
+.. |coverage| image:: https://codecov.io/gh/bluesky/ophyd-async/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/bluesky/ophyd-async
+    :alt: Test Coverage
+
+.. |pypi_version| image:: https://img.shields.io/pypi/v/ophyd-async.svg
+    :target: https://pypi.org/project/ophyd-async
+    :alt: Latest PyPI version
+
+.. |license| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
+    :target: https://opensource.org/licenses/BSD-3-Clause
+    :alt: BSD 3-Clause License
+
+.. _Bluesky Run Engine: http://blueskyproject.io/bluesky
+
+.. _Ophyd: http://blueskyproject.io/ophyd
+
+.. _dls-dodal: https://github.com/DiamondLightSource/dodal
+
+.. _EPICS: http://www.aps.anl.gov/epics/
+
+.. _Tango: https://www.tango-controls.org/
+
+..
+    Anything below this line is used when viewing README.rst and will be replaced
+    when included in index.rst
+
+See https://blueskyproject.io/ophyd-async for more detailed documentation.

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/docs/conf.py

@@ -187,6 +187,7 @@ html_theme_options = dict(
             url="https://blueskyproject.io",
         )
     ],
+    navigation_with_keys=False,
 )
 
 

ophyd-async-0.3a1/docs/user/explanations/event-loop-choice.rst

@@ -0,0 +1,52 @@
+Device Collector Event-Loop Choice
+----------------------------------
+
+In a sync context, the ophyd-async :python:`DeviceCollector` requires the bluesky event-loop
+to connect to devices. In an async context, it does not.
+
+Sync Context
+============
+
+In a sync context the run-engine must be initialized prior to connecting to devices.
+We enfore usage of the bluesky event-loop in this context.
+
+The following will fail if :python:`RE = RunEngine()` has not been called already:
+
+.. code:: python
+
+  with DeviceCollector():
+      device1 = Device1(prefix)
+      device2 = Device2(prefix)
+      device3 = Device3(prefix)
+
+The :python:`DeviceCollector` connects to devices in the event-loop created in the run-engine.
+
+
+Async Context
+=============
+
+In an async context device connection is decoupled from the run-engine.
+The following attempts connection to all the devices in the :python:`DeviceCollector`
+before or after run-engine initialization.
+
+.. code:: python
+
+  async def connection_function() :
+      async with DeviceCollector():
+          device1 = Device1(prefix)
+          device2 = Device2(prefix)
+          device3 = Device3(prefix)
+
+  asyncio.run(connection_function())
+
+The devices will be unable to be used in the run-engine unless they share the same event-loop.
+When the run-engine is initialised it will create a new background event-loop to use if one
+is not passed in with :python:`RunEngine(loop=loop)`.
+
+If the user wants to use devices in the async :python:`DeviceCollector` within the run-engine
+they can either:
+
+* Run the :python:`DeviceCollector` first and pass the event-loop into the run-engine.
+* Initialize the run-engine first and run the :python:`DeviceCollector` using the bluesky event-loop.
+
+

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/docs/user/index.rst

@@ -45,6 +45,7 @@ side-bar.
             :maxdepth: 1
 
             explanations/docs-structure
+            explanations/event-loop-choice
 
         +++
 

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/pyproject.toml

@@ -18,10 +18,11 @@ dependencies = [
     "numpy",
     "packaging",
     "pint",
-    "bluesky",
+    "bluesky>=1.13.0a3",
     "event-model",
     "p4p",
-] # Add project dependencies here, e.g. ["click", "numpy"]
+    "pyyaml",
+]
 
 dynamic = ["version"]
 license.file = "LICENSE"
@@ -34,14 +35,7 @@ pva = ["p4p"]
 dev = [
     "ophyd_async[pva]",
     "ophyd_async[ca]",
-    "attrs>=19.3.0",
     "black",
-    "bluesky>=1.11.0",
-    "caproto[standard] >=0.4.2rc1",
-    "pytest-codecov",
-    "databroker>=1.0.0b1",
-    "doctr",
-    "epics-pypdb",
     "flake8",
     "flake8-isort",
     "Flake8-pyproject",
@@ -54,6 +48,7 @@ dev = [
     "myst-parser",
     "numpydoc",
     "ophyd",
+    "pickleshare",
     "pipdeptree",
     "pre-commit",
     "pydata-sphinx-theme>=0.12",
@@ -70,6 +65,7 @@ dev = [
     "sphinx-design",
     "tox-direct",
     "types-mock",
+    "types-pyyaml",
 ]
 
 [project.scripts]

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.3a1'
+__version_tuple__ = version_tuple = (0, 3)

ophyd-async-0.3a1/src/ophyd_async/core/__init__.py

@@ -0,0 +1,96 @@
+from ._providers import (
+    DirectoryInfo,
+    DirectoryProvider,
+    NameProvider,
+    ShapeProvider,
+    StaticDirectoryProvider,
+)
+from .async_status import AsyncStatus
+from .detector import DetectorControl, DetectorTrigger, DetectorWriter, StandardDetector
+from .device import Device, DeviceCollector, DeviceVector
+from .device_save_loader import (
+    get_signal_values,
+    load_device,
+    load_from_yaml,
+    save_device,
+    save_to_yaml,
+    set_signal_values,
+    walk_rw_signals,
+)
+from .flyer import HardwareTriggeredFlyable, TriggerInfo, TriggerLogic
+from .signal import (
+    Signal,
+    SignalR,
+    SignalRW,
+    SignalW,
+    SignalX,
+    observe_value,
+    set_and_wait_for_value,
+    set_sim_callback,
+    set_sim_put_proceeds,
+    set_sim_value,
+    wait_for_value,
+)
+from .signal_backend import SignalBackend
+from .sim_signal_backend import SimSignalBackend
+from .standard_readable import StandardReadable
+from .utils import (
+    DEFAULT_TIMEOUT,
+    Callback,
+    NotConnected,
+    ReadingValueCallback,
+    T,
+    get_dtype,
+    get_unique,
+    merge_gathered_dicts,
+    wait_for_connection,
+)
+
+__all__ = [
+    "SignalBackend",
+    "SimSignalBackend",
+    "DetectorControl",
+    "DetectorTrigger",
+    "DetectorWriter",
+    "StandardDetector",
+    "Device",
+    "DeviceCollector",
+    "DeviceVector",
+    "Signal",
+    "SignalR",
+    "SignalW",
+    "SignalRW",
+    "SignalX",
+    "observe_value",
+    "set_and_wait_for_value",
+    "set_sim_callback",
+    "set_sim_put_proceeds",
+    "set_sim_value",
+    "wait_for_value",
+    "AsyncStatus",
+    "DirectoryInfo",
+    "DirectoryProvider",
+    "NameProvider",
+    "ShapeProvider",
+    "StaticDirectoryProvider",
+    "StandardReadable",
+    "TriggerInfo",
+    "TriggerLogic",
+    "HardwareTriggeredFlyable",
+    "DEFAULT_TIMEOUT",
+    "Callback",
+    "NotConnected",
+    "ReadingValueCallback",
+    "T",
+    "get_dtype",
+    "get_unique",
+    "merge_gathered_dicts",
+    "wait_for_connection",
+    "get_signal_values",
+    "load_from_yaml",
+    "save_to_yaml",
+    "set_signal_values",
+    "walk_rw_signals",
+    "load_device",
+    "save_device",
+]

ophyd-async-0.3a1/src/ophyd_async/core/_providers.py

@@ -0,0 +1,66 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Protocol, Sequence, Union
+
+
+@dataclass
+class DirectoryInfo:
+    """
+    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 prefix: Optional filename prefix to add to all files
+    :param suffix: Optional filename suffix to add to all files
+    """
+
+    root: Path
+    resource_dir: Path
+    prefix: Optional[str] = ""
+    suffix: Optional[str] = ""
+
+
+class DirectoryProvider(Protocol):
+    @abstractmethod
+    def __call__(self) -> DirectoryInfo:
+        """Get the current directory to write files into"""
+
+
+class StaticDirectoryProvider(DirectoryProvider):
+    def __init__(
+        self,
+        directory_path: Union[str, Path],
+        filename_prefix: str = "",
+        filename_suffix: str = "",
+        resource_dir: Path = Path("."),
+    ) -> None:
+        if isinstance(directory_path, str):
+            directory_path = Path(directory_path)
+        self._directory_info = DirectoryInfo(
+            root=directory_path,
+            resource_dir=resource_dir,
+            prefix=filename_prefix,
+            suffix=filename_suffix,
+        )
+
+    def __call__(self) -> DirectoryInfo:
+        return self._directory_info
+
+
+class NameProvider(Protocol):
+    @abstractmethod
+    def __call__(self) -> str:
+        """Get the name to be used as a data_key in the descriptor document"""
+
+
+class ShapeProvider(Protocol):
+    @abstractmethod
+    async def __call__(self) -> Sequence[int]:
+        """Get the shape of the data collection"""

{ophyd-async-0.1.0 → ophyd-async-0.3a1}/src/ophyd_async/core/async_status.py

@@ -1,4 +1,4 @@
-"""Equivalent of bluesky.protols.Status for asynchronous tasks."""
+"""Equivalent of bluesky.protocols.Status for asynchronous tasks."""
 
 import asyncio
 import functools
@@ -62,7 +62,9 @@ class AsyncStatus(Status):
     @property
     def success(self) -> bool:
         return (
-            self.task.done() and not self.task.cancelled() and not self.task.exception()
+            self.task.done()
+            and not self.task.cancelled()
+            and self.task.exception() is None
         )
 
     def watch(self, watcher: Callable):
@@ -83,12 +85,12 @@ class AsyncStatus(Status):
 
     def __repr__(self) -> str:
         if self.done:
-            if self.exception() is not None:
-                status = "errored"
+            if e := self.exception():
+                status = f"errored: {repr(e)}"
             else:
                 status = "done"
         else:
             status = "pending"
-        return f"<{type(self).__name__} {status}>"
+        return f"<{type(self).__name__}, task: {self.task.get_coro()}, {status}>"
 
     __str__ = __repr__