ophyd-async 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ophyd_async/tango/{signal → core}/_tango_transport.py

@@ -2,7 +2,6 @@ import asyncio
 import functools
 import time
 from abc import abstractmethod
-from asyncio import CancelledError
 from collections.abc import Callable, Coroutine
 from enum import Enum
 from typing import Any, TypeVar, cast
@@ -11,12 +10,11 @@ import numpy as np
 from bluesky.protocols import Descriptor, Reading
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     AsyncStatus,
+    Callback,
     NotConnected,
-    ReadingValueCallback,
     SignalBackend,
-    T,
+    SignalDatatypeT,
     get_dtype,
     get_unique,
     wait_for_connection,
@@ -121,7 +119,7 @@ class TangoProxy:
         """indicates, that this trl already subscribed"""
 
     @abstractmethod
-    def subscribe_callback(self, callback: ReadingValueCallback | None):
+    def subscribe_callback(self, callback: Callback | None):
         """subscribe tango CHANGE event to callback"""
 
     @abstractmethod
@@ -140,7 +138,7 @@ class TangoProxy:
 
 
 class AttributeProxy(TangoProxy):
-    _callback: ReadingValueCallback | None = None
+    _callback: Callback | None = None
     _eid: int | None = None
     _poll_task: asyncio.Task | None = None
     _abs_change: float | None = None
@@ -178,6 +176,7 @@ class AttributeProxy(TangoProxy):
     async def put(
         self, value: object | None, wait: bool = True, timeout: float | None = None
     ) -> AsyncStatus | None:
+        # TODO: remove the timeout from this as it is handled at the signal level
         if wait:
             try:
 
@@ -236,7 +235,7 @@ class AttributeProxy(TangoProxy):
     def has_subscription(self) -> bool:
         return bool(self._callback)
 
-    def subscribe_callback(self, callback: ReadingValueCallback | None):
+    def subscribe_callback(self, callback: Callback | None):
         # If the attribute supports events, then we can subscribe to them
         # If the callback is not a callable, then we raise an error
         if callback is not None and not callable(callback):
@@ -283,21 +282,20 @@ class AttributeProxy(TangoProxy):
             if self._callback is not None:
                 # Call the callback with the last reading
                 try:
-                    self._callback(self._last_reading, self._last_reading["value"])
+                    self._callback(self._last_reading)
                 except TypeError:
                     pass
         self._callback = None
 
     def _event_processor(self, event):
         if not event.err:
-            value = event.attr_value.value
             reading = Reading(
-                value=value,
+                value=event.attr_value.value,
                 timestamp=event.get_date().totime(),
                 alarm_severity=event.attr_value.quality,
             )
             if self._callback is not None:
-                self._callback(reading, value)
+                self._callback(reading)
 
     async def poll(self):
         """
@@ -310,7 +308,7 @@ class AttributeProxy(TangoProxy):
             flag = 0
             # Initial reading
             if self._callback is not None:
-                self._callback(last_reading, last_reading["value"])
+                self._callback(last_reading)
         except Exception as e:
             raise RuntimeError(f"Could not poll the attribute: {e}") from e
 
@@ -325,7 +323,7 @@ class AttributeProxy(TangoProxy):
                     diff = abs(reading["value"] - last_reading["value"])
                     if self._abs_change is not None and diff >= abs(self._abs_change):
                         if self._callback is not None:
-                            self._callback(reading, reading["value"])
+                            self._callback(reading)
                             flag = 0
 
                     elif (
@@ -333,13 +331,13 @@ class AttributeProxy(TangoProxy):
                         and diff >= self._rel_change * abs(last_reading["value"])
                     ):
                         if self._callback is not None:
-                            self._callback(reading, reading["value"])
+                            self._callback(reading)
                             flag = 0
 
                     else:
                         flag = (flag + 1) % 4
                         if flag == 0 and self._callback is not None:
-                            self._callback(reading, reading["value"])
+                            self._callback(reading)
 
                     last_reading = reading.copy()
                     if self._callback is None:
@@ -358,13 +356,13 @@ class AttributeProxy(TangoProxy):
                                 reading["value"], last_reading["value"]
                             ):
                                 if self._callback is not None:
-                                    self._callback(reading, reading["value"])
+                                    self._callback(reading)
                                 else:
                                     break
                         else:
                             if reading["value"] != last_reading["value"]:
                                 if self._callback is not None:
-                                    self._callback(reading, reading["value"])
+                                    self._callback(reading)
                                 else:
                                     break
                         last_reading = reading.copy()
@@ -390,7 +388,7 @@ class AttributeProxy(TangoProxy):
 class CommandProxy(TangoProxy):
     _last_reading: Reading = Reading(value=None, timestamp=0, alarm_severity=0)
 
-    def subscribe_callback(self, callback: ReadingValueCallback | None) -> None:
+    def subscribe_callback(self, callback: Callback | None) -> None:
         raise NotImplementedError("Cannot subscribe to commands")
 
     def unsubscribe_callback(self) -> None:
@@ -584,14 +582,14 @@ def get_trl_descriptor(
 
 
 async def get_tango_trl(
-    full_trl: str, device_proxy: DeviceProxy | TangoProxy | None
+    full_trl: str, device_proxy: DeviceProxy | TangoProxy | None, timeout: float
 ) -> TangoProxy:
     if isinstance(device_proxy, TangoProxy):
         return device_proxy
     device_trl, trl_name = full_trl.rsplit("/", 1)
     trl_name = trl_name.lower()
     if device_proxy is None:
-        device_proxy = await AsyncDeviceProxy(device_trl)
+        device_proxy = await AsyncDeviceProxy(device_trl, timeout=timeout)
 
     # all attributes can be always accessible with low register
     if isinstance(device_proxy, DeviceProxy):
@@ -620,16 +618,15 @@ async def get_tango_trl(
     raise RuntimeError(f"{trl_name} cannot be found in {device_proxy.name()}")
 
 
-class TangoSignalBackend(SignalBackend[T]):
+class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
     def __init__(
         self,
-        datatype: type[T] | None,
+        datatype: type[SignalDatatypeT] | None,
         read_trl: str = "",
         write_trl: str = "",
         device_proxy: DeviceProxy | None = None,
     ):
         self.device_proxy = device_proxy
-        self.datatype = datatype
         self.read_trl = read_trl
         self.write_trl = write_trl
         self.proxies: dict[str, TangoProxy | DeviceProxy | None] = {
@@ -646,6 +643,7 @@ class TangoSignalBackend(SignalBackend[T]):
         )
         self.support_events: bool = True
         self.status: AsyncStatus | None = None
+        super().__init__(datatype)
 
     @classmethod
     def datatype_allowed(cls, dtype: Any) -> bool:
@@ -659,14 +657,14 @@ class TangoSignalBackend(SignalBackend[T]):
             write_trl: self.device_proxy,
         }
 
-    def source(self, name: str) -> str:
-        return self.read_trl
+    def source(self, name: str, read: bool) -> str:
+        return self.read_trl if read else self.write_trl
 
-    async def _connect_and_store_config(self, trl: str) -> None:
+    async def _connect_and_store_config(self, trl: str, timeout: float) -> None:
         if not trl:
             raise RuntimeError(f"trl not set for {self}")
         try:
-            self.proxies[trl] = await get_tango_trl(trl, self.proxies[trl])
+            self.proxies[trl] = await get_tango_trl(trl, self.proxies[trl], timeout)
             if self.proxies[trl] is None:
                 raise NotConnected(f"Not connected to {trl}")
             # Pyright does not believe that self.proxies[trl] is not None despite
@@ -674,27 +672,27 @@ class TangoSignalBackend(SignalBackend[T]):
             await self.proxies[trl].connect()  # type: ignore
             self.trl_configs[trl] = await self.proxies[trl].get_config()  # type: ignore
             self.proxies[trl].support_events = self.support_events  # type: ignore
-        except CancelledError as ce:
-            raise NotConnected(f"Could not connect to {trl}") from ce
+        except TimeoutError as ce:
+            raise NotConnected(f"tango://{trl}") from ce
 
-    async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
+    async def connect(self, timeout: float) -> None:
         if not self.read_trl:
             raise RuntimeError(f"trl not set for {self}")
         if self.read_trl != self.write_trl:
             # Different, need to connect both
             await wait_for_connection(
-                read_trl=self._connect_and_store_config(self.read_trl),
-                write_trl=self._connect_and_store_config(self.write_trl),
+                read_trl=self._connect_and_store_config(self.read_trl, timeout),
+                write_trl=self._connect_and_store_config(self.write_trl, timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._connect_and_store_config(self.read_trl)
+            await self._connect_and_store_config(self.read_trl, timeout)
         self.proxies[self.read_trl].set_polling(*self._polling)  # type: ignore
         self.descriptor = get_trl_descriptor(
             self.datatype, self.read_trl, self.trl_configs
         )
 
-    async def put(self, value: T | None, wait=True, timeout=None) -> None:
+    async def put(self, value: SignalDatatypeT | None, wait=True, timeout=None) -> None:
         if self.proxies[self.write_trl] is None:
             raise NotConnected(f"Not connected to {self.write_trl}")
         self.status = None
@@ -704,28 +702,28 @@ class TangoSignalBackend(SignalBackend[T]):
     async def get_datakey(self, source: str) -> Descriptor:
         return self.descriptor
 
-    async def get_reading(self) -> Reading:
+    async def get_reading(self) -> Reading[SignalDatatypeT]:
         if self.proxies[self.read_trl] is None:
             raise NotConnected(f"Not connected to {self.read_trl}")
         return await self.proxies[self.read_trl].get_reading()  # type: ignore
 
-    async def get_value(self) -> T:
+    async def get_value(self) -> SignalDatatypeT:
         if self.proxies[self.read_trl] is None:
             raise NotConnected(f"Not connected to {self.read_trl}")
         proxy = self.proxies[self.read_trl]
         if proxy is None:
             raise NotConnected(f"Not connected to {self.read_trl}")
-        return cast(T, await proxy.get())
+        return cast(SignalDatatypeT, await proxy.get())
 
-    async def get_setpoint(self) -> T:
+    async def get_setpoint(self) -> SignalDatatypeT:
         if self.proxies[self.write_trl] is None:
             raise NotConnected(f"Not connected to {self.write_trl}")
         proxy = self.proxies[self.write_trl]
         if proxy is None:
             raise NotConnected(f"Not connected to {self.write_trl}")
-        return cast(T, await proxy.get_w_value())
+        return cast(SignalDatatypeT, await proxy.get_w_value())
 
-    def set_callback(self, callback: ReadingValueCallback | None) -> None:
+    def set_callback(self, callback: Callback | None) -> None:
         if self.proxies[self.read_trl] is None:
             raise NotConnected(f"Not connected to {self.read_trl}")
         if self.support_events is False and self._polling[0] is False:

ophyd_async/tango/demo/_counter.py

@@ -1,30 +1,19 @@
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
-    SignalR,
-    SignalRW,
-    SignalX,
-)
-from ophyd_async.tango import TangoReadable, tango_polling
+from typing import Annotated as A
+
+from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 
 
-# Enable device level polling, useful for servers that do not support events
-# Polling for individual signal can be enabled with a dict
-@tango_polling({"counts": (1.0, 0.1, 0.1), "sample_time": (0.1, 0.1, 0.1)})
 class TangoCounter(TangoReadable):
     # Enter the name and type of the signals you want to use
-    # If type is None or Signal, the type will be inferred from the Tango device
-    counts: SignalR[int]
-    sample_time: SignalRW[float]
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    counts: A[SignalR[int], Format.HINTED_SIGNAL, TangoPolling(1.0, 0.1, 0.1)]
+    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL, TangoPolling(0.1, 0.1, 0.1)]
     start: SignalX
-    _reset: SignalX
-
-    def __init__(self, trl: str | None = "", name=""):
-        super().__init__(trl, name=name)
-        self.add_readables([self.counts], HintedSignal)
-        self.add_readables([self.sample_time], ConfigSignal)
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
+    reset_: SignalX
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
@@ -34,4 +23,4 @@ class TangoCounter(TangoReadable):
 
     @AsyncStatus.wrap
     async def reset(self) -> None:
-        await self._reset.trigger(wait=True, timeout=DEFAULT_TIMEOUT)
+        await self.reset_.trigger(wait=True, timeout=DEFAULT_TIMEOUT)

ophyd_async/tango/demo/_mover.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Annotated as A
 
 from bluesky.protocols import Movable, Stoppable
 
@@ -7,8 +8,6 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
-    HintedSignal,
     SignalR,
     SignalRW,
     SignalX,
@@ -17,24 +16,25 @@ from ophyd_async.core import (
     observe_value,
     wait_for_value,
 )
-from ophyd_async.tango import TangoReadable, tango_polling
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 from tango import DevState
 
 
-# Enable device level polling, useful for servers that do not support events
-@tango_polling((0.1, 0.1, 0.1))
 class TangoMover(TangoReadable, Movable, Stoppable):
     # Enter the name and type of the signals you want to use
-    # If type is None or Signal, the type will be inferred from the Tango device
-    position: SignalRW[float]
-    velocity: SignalRW[float]
-    state: SignalR[DevState]
-    _stop: SignalX
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    position: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    velocity: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    state: A[SignalR[DevState], TangoPolling(0.1)]
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
+    stop_: SignalX
 
     def __init__(self, trl: str | None = "", name=""):
         super().__init__(trl, name=name)
-        self.add_readables([self.position], HintedSignal)
-        self.add_readables([self.velocity], ConfigSignal)
+        self.add_readables([self.position], Format.HINTED_SIGNAL)
+        self.add_readables([self.velocity], Format.CONFIG_SIGNAL)
         self._set_success = True
 
     @WatchableAsyncStatus.wrap
@@ -74,4 +74,4 @@ class TangoMover(TangoReadable, Movable, Stoppable):
 
     def stop(self, success: bool = True) -> AsyncStatus:
         self._set_success = success
-        return self._stop.trigger()
+        return self.stop_.trigger()

{ophyd_async-0.7.0.dist-info → ophyd_async-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.7.0
+Version: 0.8.0
 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
@@ -40,73 +40,70 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: networkx >=2.0
-Requires-Dist: numpy <2.0.0
+Requires-Dist: networkx>=2.0
+Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: bluesky >=1.13.0a3
-Requires-Dist: event-model
-Requires-Dist: p4p
+Requires-Dist: bluesky>=1.13
+Requires-Dist: event-model>=1.22.1
+Requires-Dist: p4p>=4.2.0a3
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
-Requires-Dist: pydantic >=2.0
+Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Provides-Extra: ca
-Requires-Dist: aioca >=1.6 ; extra == 'ca'
-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: ophyd-async[tango] ; 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: inflection ; extra == 'dev'
-Requires-Dist: ipython ; extra == 'dev'
-Requires-Dist: ipywidgets ; extra == 'dev'
-Requires-Dist: matplotlib ; 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'
-Requires-Dist: pyepics >=3.4.2 ; extra == 'dev'
-Requires-Dist: pyright ; extra == 'dev'
-Requires-Dist: pyside6 ==6.7.0 ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-asyncio ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: pytest-faulthandler ; extra == 'dev'
-Requires-Dist: pytest-forked ; extra == 'dev'
-Requires-Dist: pytest-rerunfailures ; extra == 'dev'
-Requires-Dist: pytest-timeout ; extra == 'dev'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: sphinx <7.4.0 ; extra == 'dev'
-Requires-Dist: sphinx-autobuild ; extra == 'dev'
-Requires-Dist: autodoc-pydantic ; extra == 'dev'
-Requires-Dist: sphinxcontrib-mermaid ; extra == 'dev'
-Requires-Dist: sphinx-copybutton ; extra == 'dev'
-Requires-Dist: sphinx-design ; extra == 'dev'
-Requires-Dist: super-state-machine ; extra == 'dev'
-Requires-Dist: tox-direct ; extra == 'dev'
-Requires-Dist: types-mock ; extra == 'dev'
-Requires-Dist: types-pyyaml ; extra == 'dev'
+Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
-Requires-Dist: p4p ; extra == 'pva'
+Requires-Dist: p4p; extra == "pva"
 Provides-Extra: sim
-Requires-Dist: h5py ; extra == 'sim'
+Requires-Dist: h5py; extra == "sim"
 Provides-Extra: tango
-Requires-Dist: pytango >=10.0.0 ; extra == 'tango'
+Requires-Dist: pytango>=10.0.0; extra == "tango"
+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: ophyd_async[tango]; extra == "dev"
+Requires-Dist: inflection; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: import-linter; extra == "dev"
+Requires-Dist: matplotlib; 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"
+Requires-Dist: pyepics>=3.4.2; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pyside6==6.7.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-faulthandler; extra == "dev"
+Requires-Dist: pytest-forked; extra == "dev"
+Requires-Dist: pytest-rerunfailures; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx<7.4.0; extra == "dev"
+Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: autodoc-pydantic; extra == "dev"
+Requires-Dist: sphinxcontrib-mermaid; extra == "dev"
+Requires-Dist: sphinx-copybutton; extra == "dev"
+Requires-Dist: sphinx-design; extra == "dev"
+Requires-Dist: super_state_machine; extra == "dev"
+Requires-Dist: tox-direct; extra == "dev"
+Requires-Dist: types-mock; extra == "dev"
+Requires-Dist: types-pyyaml; extra == "dev"
 
 [![CI](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/bluesky/ophyd-async/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/ophyd-async)
 [![PyPI](https://img.shields.io/pypi/v/ophyd-async.svg)](https://pypi.org/project/ophyd-async)
-[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://choosealicense.com/licenses/bsd-3-clause)
 
-# ophyd-async
+# ![ophyd-async](https://raw.githubusercontent.com/bluesky/ophyd-async/main/docs/images/ophyd-async-logo.svg)
 
 Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
@@ -116,7 +113,7 @@ Asynchronous Bluesky hardware abstraction code, compatible with control systems
 | Documentation |      <https://bluesky.github.io/ophyd-async>      |
 |   Releases    | <https://github.com/bluesky/ophyd-async/releases> |
 
-Ophyd-async is a Python library for asynchronously interfacing with hardware, intended to 
+Ophyd-async is a 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.
 

ophyd_async-0.8.0.dist-info/RECORD

@@ -0,0 +1,116 @@
+ophyd_async/__init__.py,sha256=tEfgj45lRItQ-_u8SRFPM-mpBh3gWvHXr3emhiJJG_M,225
+ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
+ophyd_async/_version.py,sha256=vspFLRfYI6gAAN7kyihey2lhPos0jxqKaNDWFlKPlmU,411
+ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/core/__init__.py,sha256=aJP0ZNIVvfbodCpUQUHXidz18W02hI2nvYhFS4Ubq1g,4339
+ophyd_async/core/_detector.py,sha256=bKLekM2J3GzLXsKwe8qXQjNP_sAVsa8EtwFEWD-8MeA,14307
+ophyd_async/core/_device.py,sha256=ygXxDKiTO43qDnLeLzrKKyABwlrfGvSVii7PHyCIjHg,12074
+ophyd_async/core/_device_filler.py,sha256=Nw-DUyuXYpvt4mmCAQaNVA0LFBBaPK84ubZo3bR39Ak,11407
+ophyd_async/core/_device_save_loader.py,sha256=OViN9_LWNOLuajzrHDKYEqd5I47u5npQACdGceKcIGY,8375
+ophyd_async/core/_flyer.py,sha256=us5z6MNGCvIfgPDTmFTxNERSP37g0WVRkRD0Z2JiMgM,1701
+ophyd_async/core/_hdf_dataset.py,sha256=wW_OL8OYLGOsE01ny3hGaapOrxK7BzhWTxKgz8CIXK0,2492
+ophyd_async/core/_log.py,sha256=UbL9AtnHVUg7r9LofzgmuKEtBESy03usCp7ejmDltG4,3679
+ophyd_async/core/_mock_signal_backend.py,sha256=8Upnz6QrSigeDXemjZ-jB4sV2yIPUzid-6GOfTZ-7Io,2805
+ophyd_async/core/_mock_signal_utils.py,sha256=YeKjStClwp1etlmHMx1tb_VV1GjeFPg83Hkq7-YPkpg,5306
+ophyd_async/core/_protocol.py,sha256=MuYRqSfakdry9RllX7G9UTzp4lw3eDjtkdGPpnbNb34,4040
+ophyd_async/core/_providers.py,sha256=ff9ZT5-PZ6rhTTdE-q8w9l_k9DuZqLWLebsKZLeJ0Ds,7112
+ophyd_async/core/_readable.py,sha256=7FxqxhAT1wBQqOEivgnY731zA9QoK1Tt-ZGcH7GBOXM,10623
+ophyd_async/core/_signal.py,sha256=GyWyk3uzLej4moei2-tKUBKZJ2SKzWGFRJ82wunv7Zs,22359
+ophyd_async/core/_signal_backend.py,sha256=YWPgLSPbfPnWIUDHvP1ArCVK8zKXJxzzbloqQe_ucCI,5040
+ophyd_async/core/_soft_signal_backend.py,sha256=w9zzD4eoD9SsJpORXNSaFOLJrD6biYBbCSVAybLa_7k,5926
+ophyd_async/core/_status.py,sha256=OUKhblRQ4KU5PDsWbpvYduM7G60JMk1NqeV4eqyPtKc,5131
+ophyd_async/core/_table.py,sha256=tNu396gDGjpX1xUBQXgKI7aiDugaBl2McH_kVZPn_kQ,5535
+ophyd_async/core/_utils.py,sha256=wzzGL7yPAMuPueGOG1cpTgh0vho5YxI86m8SSX7Z9hw,9494
+ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/motor.py,sha256=pujJXV_vslvo3AxsVySTAEoFuduuv5Hp6sz8aRvIbeQ,8792
+ophyd_async/epics/signal.py,sha256=hJCGIIWjRVhjEHkeL1I_oPEaaN7dDFKmm7G7ZmgoTYQ,219
+ophyd_async/epics/adaravis/__init__.py,sha256=u979_9nQTYB0TvDOTXFN4qMrbDP8-xQFfXYMGzLVBo4,207
+ophyd_async/epics/adaravis/_aravis.py,sha256=XBuLQBZYj2tptY39bVzXjl6t-ZpPwqrUOwpR54l-hSo,1952
+ophyd_async/epics/adaravis/_aravis_controller.py,sha256=t4vuMsQ_67tNsAYPFFtBKq3YIHhRnK08DwPzi8Am_-k,2831
+ophyd_async/epics/adaravis/_aravis_io.py,sha256=KCfylSNGN7rC6W4uJDCVtaQ4-o5_FR_bTyTDXnhmMt4,1603
+ophyd_async/epics/adcore/__init__.py,sha256=3wMOyFGaq1X61LqK4iY4pq-m_BjhOgYZD2-mNCAjpzk,1086
+ophyd_async/epics/adcore/_core_io.py,sha256=ZQjRLdpFMVS9kwEm5LAh60pxiy7XWyYtc2TzEvCEVYM,6076
+ophyd_async/epics/adcore/_core_logic.py,sha256=_RJELnIeoAceqVoLolCnhBH0XAbTKxuCzH9QJ1gqOs0,3606
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=eWT9SH7uegf9rpCWRmVCZTsOxF1drPaOAMmoXm99mVk,7215
+ophyd_async/epics/adcore/_single_trigger.py,sha256=7SzmadatWk4zXIweRIhVX5odc__ZZKuGicL7vlW0JbY,1208
+ophyd_async/epics/adcore/_utils.py,sha256=MZBKeSPIRzyo6f84MpzPp28KwOLa9qgrkMIFc618wOE,3932
+ophyd_async/epics/adkinetix/__init__.py,sha256=cvnwOqbvEENf70eFp6bPGwayP0u14UTIhs3WiZEcF_Q,262
+ophyd_async/epics/adkinetix/_kinetix.py,sha256=JsQVc4d7lRCnVObJlM775hHLfp3rYRSRgOoIyRvrSek,1184
+ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=LyK-CWkEV1l_RVhCOHf2lLgo1FRIkDCa4P8JnAGZ4us,1701
+ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=D72HNtob74SnhBa3Zsbp37MhqS6kdrCPac7pnTlm0PQ,910
+ophyd_async/epics/adpilatus/__init__.py,sha256=daimScOCCMHR2eb8VbezHOcGOkd6uIRZQiyeTQsaAx4,308
+ophyd_async/epics/adpilatus/_pilatus.py,sha256=AbWfxEds8ESB73kRXz56FzRPYqy67Ue0m11HRaNUqZY,1751
+ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=eBZnNPHJosYAMdD-efLNgAmTYaqONLJ3qKX-2RW13fg,2676
+ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=upIc5mr8RMmPjQMZcG7-Y8C9a5nPl91OTDjZ5JYDVIc,738
+ophyd_async/epics/adsimdetector/__init__.py,sha256=t3crUgTEvVJGI8o6FsfN42k0A-l4v9ZBwXIYtixoE-M,128
+ophyd_async/epics/adsimdetector/_sim.py,sha256=jzsPJdcwdciR2mVPbvg9KhGHWWGNDQwK5TwPcS7_tco,1009
+ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=lxBCJtREDOySrpLNl7_9DbuIw2IhRpSOBK_CvJ5XBs4,1677
+ophyd_async/epics/advimba/__init__.py,sha256=l0ElP3Zyff_pzrTRdj9oUO9xigCfmzo3pMVjstlVsJY,320
+ophyd_async/epics/advimba/_vimba.py,sha256=E_RJ0uJQt-RWAY7uFTNkHaOdGYS5sa7ZbRgAe6ngXTA,1125
+ophyd_async/epics/advimba/_vimba_controller.py,sha256=Ej7irxTab9cfjmqz4G4Zxv3CjhJw_eRmIb3E62YWh6g,2226
+ophyd_async/epics/advimba/_vimba_io.py,sha256=F3KUzMN-GMe637za-iRVGGTt8v9F1a79fRcl3MCkfXA,1864
+ophyd_async/epics/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
+ophyd_async/epics/core/_aioca.py,sha256=iQWiHWYbMJLa7qeBrCz4_e16Y8A-NYYi6oYNi8oOFVY,11617
+ophyd_async/epics/core/_epics_connector.py,sha256=n1FlQYui8HdobPxaX3VAflrzi2UT7QCe3cFasssmVLw,1789
+ophyd_async/epics/core/_epics_device.py,sha256=kshNiKQhevsL2OZXa-r093L_sQGvGK_0J4PWVLg3Eqw,437
+ophyd_async/epics/core/_p4p.py,sha256=S6zXXApRF0454aOcxUI_cd7Y7tXiOnss_ODhjjk0PMo,14691
+ophyd_async/epics/core/_pvi_connector.py,sha256=Rjc8g3Rdny_O-4JxhoCpD4L7XWIRq-lnGHXKpsIUrSU,3621
+ophyd_async/epics/core/_signal.py,sha256=jHdMXV1-0bd7PC8XV32Sso1xgubZVDhWFNsWV-UuamQ,4642
+ophyd_async/epics/core/_util.py,sha256=6CCWDfp54WeBIJdGjg_YBVZTKoNjponWyykMmLPrj7U,1820
+ophyd_async/epics/demo/__init__.py,sha256=wCrgemEo-zR4TTvaqCKnQ-AIUHorotV5jhftbq1tXz0,1368
+ophyd_async/epics/demo/_mover.py,sha256=uyg60SlL7k2C3KA_05EUFOlDe6RB5QBbw7QGs969ItQ,3571
+ophyd_async/epics/demo/_sensor.py,sha256=ATlS5jejoHzpgjHhEienEmRguTzZ7DGvzZkuPCHY49U,1040
+ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
+ophyd_async/epics/demo/sensor.db,sha256=AstyG9E0R4KZBz2FZQSrV_QlrfLoU6M2cvYc15Lf548,553
+ophyd_async/epics/eiger/__init__.py,sha256=b3Tt4pVLk23Giyj50R4e94d2MxWDDmNHWhWwNq2jlaw,221
+ophyd_async/epics/eiger/_eiger.py,sha256=hkMsjVwrzDcE1u5BRIQtn8RSR2e0b1JMpDvuIONoNaI,1133
+ophyd_async/epics/eiger/_eiger_controller.py,sha256=u7T5--97VLm3pbz3E3Lxumb7hzKLzUN18wDtRj_AVZA,2343
+ophyd_async/epics/eiger/_eiger_io.py,sha256=0iimpsa8TI2mJ8hTolQByIhdeKltUGcg6aEkY5GwIyQ,1806
+ophyd_async/epics/eiger/_odin_io.py,sha256=3E33ysvMlf8t0bbSVPnzUrvPgUwA7491uoViWpivpf8,4153
+ophyd_async/epics/testing/__init__.py,sha256=terWt7TtNaxk4dCdAGQs-7HM2Z7Vcy34eX6kcngDbi8,498
+ophyd_async/epics/testing/_example_ioc.py,sha256=C0fDqsjpCbD_XaqZ6ti_t-SJTr2vsjt356PJqK1WC4Y,3377
+ophyd_async/epics/testing/_utils.py,sha256=-D6aKJydhM-n6290DyyKlnwCHFkbQ-j4tu5AD2JjWZ0,2443
+ophyd_async/epics/testing/test_records.db,sha256=zbucdyUKYOTQAkF-u8dei08VCrrX7LlDyQd1zKTLQ-w,3078
+ophyd_async/epics/testing/test_records_pva.db,sha256=NyceNGaCZXNYaXjH2VLhvKl8Z-L6dwfE_kYZKqdIcTU,4054
+ophyd_async/fastcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/fastcs/core.py,sha256=kykwmblZfj9xfakL8FTAqmPmPA8qRbQ90OS3d8WLyto,342
+ophyd_async/fastcs/odin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/fastcs/panda/__init__.py,sha256=_o7n7ckoTM6hTRHpLphpL7r_9sADE59MRNM0gq_ut2o,980
+ophyd_async/fastcs/panda/_block.py,sha256=STQo6NJAqIVfxyMf-2pxINPyr9_nKtXSdicp92a25xo,1709
+ophyd_async/fastcs/panda/_control.py,sha256=61vcJMjYQiUGAM5J0SfkfthFs7U28m9Pe9mgmGGf0-w,1021
+ophyd_async/fastcs/panda/_hdf_panda.py,sha256=WdgWgdrU2yT4keH70VG-ZBVOmT-IpKVyukEuKk7QnJs,1049
+ophyd_async/fastcs/panda/_table.py,sha256=5YyAfsl3H7kxH3bDjUKHuH9DyrWQmAn9dv-v0NYzFNo,2289
+ophyd_async/fastcs/panda/_trigger.py,sha256=forImtdnDnaZ0KKhqSxCqwHWXq13SJ4mn9wdM4yqNLY,3056
+ophyd_async/fastcs/panda/_utils.py,sha256=NdvzdKy0SOG1eCVMQo_nwRXpBo0wyi6lM5Xw3HvssOw,508
+ophyd_async/fastcs/panda/_writer.py,sha256=wDN6uWX1ENofmI3JBXJ7_CGooI7WsZP-JJQrRiSc6sM,6000
+ophyd_async/plan_stubs/__init__.py,sha256=wjpEj_BoBZJ9x2fhUPY6BzWMqyYH96JrBlJvV7frdN4,524
+ophyd_async/plan_stubs/_ensure_connected.py,sha256=uoqfAzghjifdfD_JM860TvMvj9T2Y12nKPvtI5l6zZc,1021
+ophyd_async/plan_stubs/_fly.py,sha256=WxghBAHsF-8xFrILCm44jeHIu9udLhm-tj4JXd9kZjY,6208
+ophyd_async/plan_stubs/_nd_attributes.py,sha256=TVfy3bhnrLFBXZ6b2bREBj0LzEviEGzuGvgWK3I7tII,2198
+ophyd_async/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/sim/demo/__init__.py,sha256=JKWFnHqmFuRRMvvU0aBuclke3OdF0iq89yvHEd4J7Bg,371
+ophyd_async/sim/demo/_sim_motor.py,sha256=hZAoZniLd-Fh5Ru9v6TyFNJHrQB_l9ljM04vByuz_Ls,3665
+ophyd_async/sim/demo/_pattern_detector/__init__.py,sha256=o_dSZDIl_CyS3YPSNKpGiQiR9UaC4cNzZ8_ByEN9dIk,402
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py,sha256=R-UbcxHLFfCK9tBryKZN5Dit0IjYeJGP-QKV2ssKFoQ,1275
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py,sha256=HqlKNgjd_9pjy6pc74xdJ7JtV1Iko6cNxB2aZReJozw,1999
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py,sha256=nQOks4EK1Ax0Ib1pkCrmJPF8Jqr7tPusMnby-HGUnP0,1370
+ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py,sha256=gP0Q1-1p_3KOH7mWZc5m-8OUEx_jb7SAdRXcpleRqX4,7096
+ophyd_async/sim/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/tango/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/tango/core/__init__.py,sha256=pBslTNkIt22-g-CDbG9N7pKLQVJqFe6DYXHFFYJZIo8,905
+ophyd_async/tango/core/_base_device.py,sha256=IN1HF1DOf9W9_FhVlzWyuU58gBFu86rYOD1vDZ_a7Wc,4717
+ophyd_async/tango/core/_signal.py,sha256=5ks0dyzCX66cV9R_CnmM949H1RzNQH3Q1XIUhHQCOaI,6421
+ophyd_async/tango/core/_tango_readable.py,sha256=c6xVH56oBp5o3C3y3PuHA5MftvmjKm20BBvrgsTO260,913
+ophyd_async/tango/core/_tango_transport.py,sha256=DVTdLu8C19k-QzYaKUzFK2WMbaSd6dIO77k99ugD8U4,28990
+ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
+ophyd_async/tango/demo/_counter.py,sha256=efBqrFj6ejzDh1aggtPXpn1iub1zB4XocRvHqBEiwcs,1105
+ophyd_async/tango/demo/_detector.py,sha256=0wwk7Y-Dl9QF1YsCIU_BxqI6-PQ40qN_0gknrYBkxsY,1292
+ophyd_async/tango/demo/_mover.py,sha256=c5whb380th1eCThs35ftW1bfNRyYRmcofg7xUp6zvV8,2837
+ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
+ophyd_async/tango/demo/_tango/_servers.py,sha256=MwkkoZWJQm_cgafCBBXeQfwyAiOgU8cE90_uNfcdcGA,2916
+ophyd_async-0.8.0.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.8.0.dist-info/METADATA,sha256=Kb1qZ7dqyg95NcgzbruGtpoQvZ3qW8li7xONx178PGc,6700
+ophyd_async-0.8.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+ophyd_async-0.8.0.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.8.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.8.0.dist-info/RECORD,,

{ophyd_async-0.7.0.dist-info → ophyd_async-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ophyd_async/epics/pvi/__init__.py

@@ -1,3 +0,0 @@
-from ._pvi import create_children_from_annotations, fill_pvi_entries
-
-__all__ = ["fill_pvi_entries", "create_children_from_annotations"]