ophyd-async 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

ophyd_async/_version.py

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

ophyd_async/core/__init__.py

@@ -50,7 +50,7 @@ from .signal import (
     soft_signal_rw,
     wait_for_value,
 )
-from .signal_backend import SignalBackend
+from .signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
 from .soft_signal_backend import SoftSignalBackend
 from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
@@ -68,66 +68,69 @@ from .utils import (
 )
 
 __all__ = [
-    "get_mock_put",
-    "callback_on_mock_put",
-    "mock_puts_blocked",
-    "set_mock_values",
-    "reset_mock_put_calls",
-    "SignalBackend",
-    "SoftSignalBackend",
+    "AsyncStatus",
+    "CalculatableTimeout",
+    "CalculateTimeout",
+    "Callback",
+    "ConfigSignal",
+    "DEFAULT_TIMEOUT",
     "DetectorControl",
-    "MockSignalBackend",
     "DetectorTrigger",
     "DetectorWriter",
-    "StandardDetector",
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "Signal",
-    "SignalR",
-    "SignalW",
-    "SignalRW",
-    "SignalX",
-    "soft_signal_r_and_setter",
-    "soft_signal_rw",
-    "observe_value",
-    "set_and_wait_for_value",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "wait_for_value",
-    "AsyncStatus",
-    "WatchableAsyncStatus",
     "DirectoryInfo",
     "DirectoryProvider",
+    "HardwareTriggeredFlyable",
+    "HintedSignal",
+    "MockSignalBackend",
     "NameProvider",
+    "NotConnected",
+    "ReadingValueCallback",
+    "RuntimeSubsetEnum",
+    "SubsetEnum",
     "ShapeProvider",
-    "StaticDirectoryProvider",
+    "Signal",
+    "SignalBackend",
+    "SignalR",
+    "SignalRW",
+    "SignalW",
+    "SignalX",
+    "SoftSignalBackend",
+    "StandardDetector",
     "StandardReadable",
-    "ConfigSignal",
-    "HintedSignal",
+    "StaticDirectoryProvider",
+    "T",
     "TriggerInfo",
     "TriggerLogic",
-    "HardwareTriggeredFlyable",
-    "CalculateTimeout",
-    "CalculatableTimeout",
-    "DEFAULT_TIMEOUT",
-    "Callback",
-    "NotConnected",
-    "ReadingValueCallback",
-    "T",
+    "WatchableAsyncStatus",
+    "assert_configuration",
+    "assert_emitted",
+    "assert_mock_put_called_with",
+    "assert_reading",
+    "assert_value",
+    "callback_on_mock_put",
     "get_dtype",
-    "get_unique",
-    "merge_gathered_dicts",
-    "wait_for_connection",
+    "get_mock_put",
     "get_signal_values",
+    "get_unique",
+    "load_device",
     "load_from_yaml",
+    "merge_gathered_dicts",
+    "mock_puts_blocked",
+    "observe_value",
+    "reset_mock_put_calls",
+    "save_device",
     "save_to_yaml",
+    "set_and_wait_for_value",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
     "set_signal_values",
+    "soft_signal_r_and_setter",
+    "soft_signal_rw",
+    "wait_for_connection",
+    "wait_for_value",
     "walk_rw_signals",
-    "load_device",
-    "save_device",
-    "assert_reading",
-    "assert_value",
-    "assert_configuration",
-    "assert_emitted",
 ]

ophyd_async/core/signal_backend.py

@@ -1,5 +1,13 @@
 from abc import abstractmethod
-from typing import Generic, Optional, Type
+from typing import (
+    TYPE_CHECKING,
+    ClassVar,
+    Generic,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+)
 
 from bluesky.protocols import DataKey, Reading
 
@@ -45,3 +53,41 @@ class SignalBackend(Generic[T]):
     @abstractmethod
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
         """Observe changes to the current value, timestamp and severity"""
+
+
+class _RuntimeSubsetEnumMeta(type):
+    def __str__(cls):
+        if hasattr(cls, "choices"):
+            return f"SubsetEnum{list(cls.choices)}"
+        return "SubsetEnum"
+
+    def __getitem__(cls, _choices):
+        if isinstance(_choices, str):
+            _choices = (_choices,)
+        else:
+            if not isinstance(_choices, tuple) or not all(
+                isinstance(c, str) for c in _choices
+            ):
+                raise TypeError(
+                    "Choices must be a str or a tuple of str, " f"not {type(_choices)}."
+                )
+            if len(set(_choices)) != len(_choices):
+                raise TypeError("Duplicate elements in runtime enum choices.")
+
+        class _RuntimeSubsetEnum(cls):
+            choices = _choices
+
+        return _RuntimeSubsetEnum
+
+
+class RuntimeSubsetEnum(metaclass=_RuntimeSubsetEnumMeta):
+    choices: ClassVar[Tuple[str, ...]]
+
+    def __init__(self):
+        raise RuntimeError("SubsetEnum cannot be instantiated")
+
+
+if TYPE_CHECKING:
+    SubsetEnum = Literal
+else:
+    SubsetEnum = RuntimeSubsetEnum

ophyd_async/core/soft_signal_backend.py

@@ -3,14 +3,23 @@ from __future__ import annotations
 import inspect
 import time
 from collections import abc
-from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Generic, Optional, Type, TypedDict, Union, cast, get_origin
+from typing import (
+    Dict,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+    get_origin,
+)
 
 import numpy as np
 from bluesky.protocols import DataKey, Dtype, Reading
 
-from .signal_backend import SignalBackend
+from .signal_backend import RuntimeSubsetEnum, SignalBackend
 from .utils import DEFAULT_TIMEOUT, ReadingValueCallback, T, get_dtype
 
 primitive_dtypes: Dict[type, Dtype] = {
@@ -74,23 +83,24 @@ class SoftArrayConverter(SoftConverter):
         return cast(T, datatype(shape=0))  # type: ignore
 
 
-@dataclass
 class SoftEnumConverter(SoftConverter):
-    enum_class: Type[Enum]
+    choices: Tuple[str, ...]
 
-    def write_value(self, value: Union[Enum, str]) -> Enum:
-        if isinstance(value, Enum):
-            return value
+    def __init__(self, datatype: Union[RuntimeSubsetEnum, Enum]):
+        if issubclass(datatype, Enum):
+            self.choices = tuple(v.value for v in datatype)
         else:
-            return self.enum_class(value)
+            self.choices = datatype.choices
+
+    def write_value(self, value: Union[Enum, str]) -> str:
+        return value
 
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
-        choices = [e.value for e in self.enum_class]
         return {
             "source": source,
             "dtype": "string",
             "shape": [],
-            "choices": choices,
+            "choices": self.choices,
             **metadata,
         }
 
@@ -98,13 +108,17 @@ class SoftEnumConverter(SoftConverter):
         if datatype is None:
             return cast(T, None)
 
-        return cast(T, list(datatype.__members__.values())[0])  # type: ignore
+        if issubclass(datatype, Enum):
+            return cast(T, list(datatype.__members__.values())[0])  # type: ignore
+        return cast(T, self.choices[0])
 
 
 def make_converter(datatype):
     is_array = get_dtype(datatype) is not None
     is_sequence = get_origin(datatype) == abc.Sequence
-    is_enum = issubclass(datatype, Enum) if inspect.isclass(datatype) else False
+    is_enum = inspect.isclass(datatype) and (
+        issubclass(datatype, Enum) or issubclass(datatype, RuntimeSubsetEnum)
+    )
 
     if is_array or is_sequence:
         return SoftArrayConverter()

ophyd_async/epics/_backend/common.py

@@ -1,6 +1,9 @@
+import inspect
 from enum import Enum
 from typing import Dict, Optional, Tuple, Type, TypedDict
 
+from ophyd_async.core.signal_backend import RuntimeSubsetEnum
+
 common_meta = {
     "units",
     "precision",
@@ -30,19 +33,30 @@ def get_supported_values(
     datatype: Optional[Type[str]],
     pv_choices: Tuple[str, ...],
 ) -> Dict[str, str]:
-    if not datatype:
+    if inspect.isclass(datatype) and issubclass(datatype, RuntimeSubsetEnum):
+        if not set(datatype.choices).issubset(set(pv_choices)):
+            raise TypeError(
+                f"{pv} has choices {pv_choices}, "
+                f"which is not a superset of {str(datatype)}."
+            )
         return {x: x or "_" for x in pv_choices}
+    elif inspect.isclass(datatype) and issubclass(datatype, Enum):
+        if not issubclass(datatype, str):
+            raise TypeError(
+                f"{pv} is type Enum but {datatype} does not inherit from String."
+            )
 
-    if not issubclass(datatype, str):
-        raise TypeError(f"{pv} is type Enum but doesn't inherit from String")
-    if issubclass(datatype, Enum):
         choices = tuple(v.value for v in datatype)
         if set(choices) != set(pv_choices):
             raise TypeError(
-                (
-                    f"{pv} has choices {pv_choices}, "
-                    f"which do not match {datatype}, which has {choices}"
-                )
+                f"{pv} has choices {pv_choices}, "
+                f"which do not match {datatype}, which has {choices}."
             )
-        return {x: datatype(x) for x in pv_choices}
-    return {x: x for x in pv_choices}
+        return {x: datatype(x) if x else "_" for x in pv_choices}
+    elif datatype is None:
+        return {x: x or "_" for x in pv_choices}
+
+    raise TypeError(
+        f"{pv} has choices {pv_choices}. "
+        "Use an Enum or SubsetEnum to represent this."
+    )

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -5,6 +5,7 @@ from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.core.detector import DetectorControl, DetectorTrigger
 from ophyd_async.epics.areadetector.drivers.ad_base import (
+    set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
 from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
@@ -39,7 +40,9 @@ class PilatusController(DetectorControl):
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         if exposure is not None:
-            await self._drv.acquire_time.set(exposure)
+            await set_exposure_time_and_acquire_period_if_supplied(
+                self, self._drv, exposure
+            )
         await asyncio.gather(
             self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
             self._drv.num_images.set(999_999 if num == 0 else num),

ophyd_async/epics/areadetector/drivers/__init__.py

@@ -2,6 +2,7 @@ from .ad_base import (
     ADBase,
     ADBaseShapeProvider,
     DetectorState,
+    set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
 from .aravis_driver import AravisDriver
@@ -17,5 +18,6 @@ __all__ = [
     "KinetixDriver",
     "VimbaDriver",
     "start_acquiring_driver_and_ensure_status",
+    "set_exposure_time_and_acquire_period_if_supplied",
     "DetectorState",
 ]

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -5,6 +5,7 @@ from typing import FrozenSet, Sequence, Set
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DetectorControl,
     ShapeProvider,
     set_and_wait_for_value,
 )
@@ -44,6 +45,7 @@ class ADBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # Define some signals
         self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
+        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
         self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
         self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
         self.detector_state = epics_signal_r(
@@ -52,6 +54,36 @@ class ADBase(NDArrayBase):
         super().__init__(prefix, name=name)
 
 
+async def set_exposure_time_and_acquire_period_if_supplied(
+    controller: DetectorControl,
+    driver: ADBase,
+    exposure: float | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> None:
+    """
+    Sets the exposure time if it is not None and the acquire period to the
+    exposure time plus the deadtime. This is expected behavior for most
+    AreaDetectors, but some may require more specialized handling.
+
+    Parameters
+    ----------
+    controller:
+        Controller that can supply a deadtime.
+    driver:
+        The driver to start acquiring. Must subclass ADBase.
+    exposure:
+        Desired exposure time, this is a noop if it is None.
+    timeout:
+        How long to wait for the exposure time and acquire period to be set.
+    """
+    if exposure is not None:
+        full_frame_time = exposure + controller.get_deadtime(exposure)
+        await asyncio.gather(
+            driver.acquire_time.set(exposure, timeout=timeout),
+            driver.acquire_period.set(full_frame_time, timeout=timeout),
+        )
+
+
 async def start_acquiring_driver_and_ensure_status(
     driver: ADBase,
     good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -1,6 +1,6 @@
 from enum import Enum
-from typing import Literal
 
+from ophyd_async.core import SubsetEnum
 from ophyd_async.epics.areadetector.drivers import ADBase
 from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
 
@@ -19,7 +19,7 @@ class AravisTriggerMode(str, Enum):
     To prevent requiring one Enum class per possible configuration, we set as this Enum
     but read from the underlying signal as a str.
     """
-AravisTriggerSource = Literal["Freerun", "Line1", "Line2", "Line3", "Line4"]
+AravisTriggerSource = SubsetEnum["Freerun", "Line1"]
 
 
 class AravisDriver(ADBase):
@@ -34,5 +34,7 @@ class AravisDriver(ADBase):
         self.trigger_mode = epics_signal_rw_rbv(
             AravisTriggerMode, prefix + "TriggerMode"
         )
-        self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
+        self.trigger_source = epics_signal_rw_rbv(
+            AravisTriggerSource, prefix + "TriggerSource"
+        )
         super().__init__(prefix, name=name)

ophyd_async/epics/motion/motor.py

@@ -95,5 +95,3 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
         await self.motor_stop.trigger(wait=False)
-        # Trigger any callbacks
-        await self.user_readback._backend.put(await self.user_readback.get_value())

{ophyd_async-0.3.2.dist-info → ophyd_async-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.2
+Version: 0.3.4
 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

{ophyd_async-0.3.2.dist-info → ophyd_async-0.3.4.dist-info}/RECORD

@@ -1,9 +1,9 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=9jP8Fo8egXoMs_T3DFqSuJYg4n9o9mnwYubl_hnut4k,411
+ophyd_async/_version.py,sha256=gK2CDe_mbvAwKw5ZjOIg75LuB0kCZ4LyDYjtXPapvJw,411
 ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
 ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
-ophyd_async/core/__init__.py,sha256=znjVeRfrDVJbGLEkUczeKMW46kV6HDrlE4lV0SqvZt4,2952
+ophyd_async/core/__init__.py,sha256=xqO9riU_uKqGAOi0ty0cbcI4Oawi_J3XTYLtwNSXGOE,3061
 ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
 ophyd_async/core/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
 ophyd_async/core/detector.py,sha256=NMX8y_yiViHbv3CaJ7LxzXYkH6tCWI3LocpQ3w4lGEQ,11176
@@ -13,15 +13,15 @@ ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,230
 ophyd_async/core/mock_signal_backend.py,sha256=Ug6jK72wm9vM6EueoUrYgcXtiFzdPUEISRe86LdyYKc,2844
 ophyd_async/core/mock_signal_utils.py,sha256=LE8VxNq3jfaTePnHHpZpKCi1vwKi8EIg-g1jfw-Q5bQ,4726
 ophyd_async/core/signal.py,sha256=hPpMcdq7zx6HOkyQCJrMD5F3uLBEJJTfwL6DsbcTELo,17601
-ophyd_async/core/signal_backend.py,sha256=fT3q0WED3JHmNKYCs7PzDLCK4cUPVin3wQjDNPdHqAY,1525
-ophyd_async/core/soft_signal_backend.py,sha256=n1Wp0jzgKTkQPlDnlUIr8Bm4JUwWc97dXiOWGjpwf4s,5926
+ophyd_async/core/signal_backend.py,sha256=U9J6jzHXRNIrdtGiZBVxXTRtzeejXiXEEIOGRIQhiS8,2678
+ophyd_async/core/soft_signal_backend.py,sha256=tBVt3iB3KW3vNGpQ-j_bO4_n-8oii-ZUdZNkfVfGThg,6161
 ophyd_async/core/standard_readable.py,sha256=fhq_WAZtLYWrw6DvvrFRYRAPOUP2_IcX4qLucoEEeOg,9049
 ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/_backend/_aioca.py,sha256=YsKHGaHtYjBte5Tz-AftTENaeV6UGRnonX-1UmAQGqg,11319
 ophyd_async/epics/_backend/_p4p.py,sha256=oCT8MeVWlhmsxZ8YRSrelrY8W3NvfpXcMlfAKL_AUNY,14331
-ophyd_async/epics/_backend/common.py,sha256=VDL4hiSn-C_yF3-PZoc46IXnmOHyrClNwIwLzEvx9Ww,1259
+ophyd_async/epics/_backend/common.py,sha256=ffdcKhtUc8Mmm0AsV0K7cUoOttF6avcN6Kdd4QHjrSw,1833
 ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
 ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
 ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
@@ -33,11 +33,11 @@ ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR
 ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
 ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
 ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
-ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=jJdY97JATz-bWtEPtmnyQ-Zyjvhy2M78i0wUuXO2dtE,2617
+ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=6AiMz2yBA9xig-BrAIAc9CDxwM4Cjfebc4dd7QRutB0,2740
 ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
-ophyd_async/epics/areadetector/drivers/__init__.py,sha256=-Ib0Lz4fFQQmB7K0uFxMDvAerkLxadMQERH7lNAvrs4,495
-ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=18WFAiWEUg0H2LcvTQHrKYj2wThGafQzDpiyAWki6vo,3411
-ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=PmIygsVNoxxYHvZZzFAbAm2DXmXFc13nAzL_DJB6YSU,1464
+ophyd_async/epics/areadetector/drivers/__init__.py,sha256=X-KdXw7YWNXpaUCXby2Spqvho2x2n72OavR-3mRlxzk,605
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=OMySyCE9dcFRcVLC5Q0wUkri3QtRljIbn4KFdkumI4M,4553
+ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=K1if0Nv1ZNEvcOha6NVYA9t9VqsBNxKCmbajlysGF2Q,1491
 ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
 ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DBBuiR_FtwzVVdDW0ifdSrdKZtnprWuy87g66o8RlQ,619
 ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
@@ -52,7 +52,7 @@ ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=06y65yvaqXvL2rDocjYyLz9kTV
 ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
 ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
 ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
-ophyd_async/epics/motion/motor.py,sha256=G8cc-okSXJ6s2fGxRO155xm7PrBbVImBmBMRWts895k,3630
+ophyd_async/epics/motion/motor.py,sha256=tqLV4TaW2MIapZsmx4wxnGOdKfkhxKLUPbTHA4YLdYE,3514
 ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
 ophyd_async/epics/pvi/pvi.py,sha256=Kc3klnA9F82h_p2atFYXe-wFO9OzN5TV69Tc56tD2do,12204
 ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
@@ -78,9 +78,9 @@ ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLin
 ophyd_async/sim/sim_pattern_generator.py,sha256=L4jTnEVUFBRXIWq_UMHqx00YDdbGO2pjo_IuuVwpzXE,1258
 ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
 ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
-ophyd_async-0.3.2.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.3.2.dist-info/METADATA,sha256=Jb_3qY-9kWt64Ko26THH3TIjLgYf_2dzEccB1cGa2q4,6292
-ophyd_async-0.3.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ophyd_async-0.3.2.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.3.2.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.3.2.dist-info/RECORD,,
+ophyd_async-0.3.4.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3.4.dist-info/METADATA,sha256=0hkgwQmGRphuOSmg_-EOyQIdEuYWGY1z4s9Bco9oG3E,6292
+ophyd_async-0.3.4.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+ophyd_async-0.3.4.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3.4.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3.4.dist-info/RECORD,,

{ophyd_async-0.3.2.dist-info → ophyd_async-0.3.4.dist-info}/WHEEL

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