ophyd-async 0.13.6__py3-none-any.whl → 0.13.7__py3-none-any.whl

ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.6'
-__version_tuple__ = version_tuple = (0, 13, 6)
+__version__ = version = '0.13.7'
+__version_tuple__ = version_tuple = (0, 13, 7)
 
 __commit_id__ = commit_id = None

ophyd_async/core/_signal.py

@@ -639,9 +639,10 @@ async def set_and_wait_for_other_value(
             if wait_for_set_completion:
                 await status
         except TimeoutError as exc:
+            matcher_name = getattr(matcher, "__name__", f"<{type(matcher).__name__}>")
             raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
-                f" {matcher.__name__}() in {timeout}s"
+                f" {matcher_name}() in {timeout}s"
             ) from exc
 
     return status

ophyd_async/epics/motor.py

@@ -98,9 +98,12 @@ class Motor(
         self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
         self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
         self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+        self.dial_low_limit_travel = epics_signal_rw(float, prefix + ".DLLM")
+        self.dial_high_limit_travel = epics_signal_rw(float, prefix + ".DHLM")
         self.offset_freeze_switch = epics_signal_rw(OffsetMode, prefix + ".FOFF")
         self.high_limit_switch = epics_signal_r(int, prefix + ".HLS")
         self.low_limit_switch = epics_signal_r(int, prefix + ".LLS")
+        self.output_link = epics_signal_r(str, prefix + ".OUT")
         self.set_use_switch = epics_signal_rw(UseSetMode, prefix + ".SET")
 
         # Note:cannot use epics_signal_x here, as the motor record specifies that
@@ -131,16 +134,26 @@ class Motor(
         Will raise a MotorLimitsException if the given absolute positions will be
         outside the motor soft limits.
         """
-        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+        (
+            motor_lower_limit,
+            motor_upper_limit,
+            egu,
+            dial_lower_limit,
+            dial_upper_limit,
+        ) = await asyncio.gather(
             self.low_limit_travel.get_value(),
             self.high_limit_travel.get_value(),
             self.motor_egu.get_value(),
+            self.dial_low_limit_travel.get_value(),
+            self.dial_high_limit_travel.get_value(),
         )
 
-        # EPICS motor record treats limits of 0, 0 as no limit
-        if motor_lower_limit == 0 and motor_upper_limit == 0:
+        # EPICS motor record treats dial limits of 0, 0 as no limit
+        # Use DLLM and DHLM to check
+        if dial_lower_limit == 0 and dial_upper_limit == 0:
             return
 
+        # Use real motor limit(i.e. HLM and LLM) to check if the move is permissible
         if (
             not motor_upper_limit >= abs_start_pos >= motor_lower_limit
             or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
@@ -150,6 +163,8 @@ class Motor(
                 f"{abs_start_pos}{egu} to "
                 f"{abs_end_pos}{egu} but motor limits are "
                 f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+                f"dial limits are "
+                f"{dial_lower_limit}{egu} <= x <= {dial_upper_limit}"
             )
 
     @AsyncStatus.wrap

ophyd_async/epics/pmac/_pmac_io.py

@@ -6,7 +6,8 @@ from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
 from ophyd_async.epics import motor
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
-CS_LETTERS = "ABCUVWXYZ"
+# Map the CS axis letters to their index (1 indexed)
+CS_INDEX = {letter: index + 1 for index, letter in enumerate("ABCUVWXYZ")}
 
 
 class PmacTrajectoryIO(StandardReadable):
@@ -20,24 +21,20 @@ class PmacTrajectoryIO(StandardReadable):
         # 1 indexed CS axes so we can index into them from the compound motor input link
         self.positions = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}{letter}:Positions"
-                )
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(Array1D[np.float64], f"{prefix}{letter}:Positions")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.use_axis = DeviceVector(
             {
-                i + 1: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.velocities = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}{letter}:Velocities"
-                )
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(Array1D[np.float64], f"{prefix}{letter}:Velocities")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.total_points = epics_signal_r(int, f"{prefix}TotalPoints_RBV")
@@ -76,8 +73,8 @@ class PmacCoordIO(Device):
         self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(float, f"{prefix}M{i + 1}:DirectDemand")
-                for i in range(len(CS_LETTERS))
+                i: epics_signal_rw(float, f"{prefix}M{i}:DirectDemand")
+                for i in CS_INDEX.values()
             }
         )
         super().__init__(name=name)

ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -15,10 +15,10 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.pmac import PmacIO
-from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
-from ophyd_async.epics.pmac._pmac_trajectory_generation import PVT, Trajectory
-from ophyd_async.epics.pmac._utils import (
+
+from ._pmac_io import CS_INDEX, PmacIO
+from ._pmac_trajectory_generation import PVT, Trajectory
+from ._utils import (
     _PmacMotorInfo,
     calculate_ramp_position_and_duration,
 )
@@ -131,8 +131,7 @@ class PmacTrajectoryTriggerLogic(FlyerController):
             slice, path_length, motor_info, ramp_up_time
         )
         use_axis = {
-            axis + 1: (axis in motor_info.motor_cs_index.values())
-            for axis in range(len(CS_LETTERS))
+            i: (i in motor_info.motor_cs_index.values()) for i in CS_INDEX.values()
         }
 
         coros = [
@@ -177,14 +176,14 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         self, trajectory: Trajectory, motor_info: _PmacMotorInfo
     ):
         coros = []
-        for motor, number in motor_info.motor_cs_index.items():
+        for motor, cs_index in motor_info.motor_cs_index.items():
             coros.append(
-                self.pmac.trajectory.positions[number + 1].set(
+                self.pmac.trajectory.positions[cs_index].set(
                     trajectory.positions[motor]
                 )
             )
             coros.append(
-                self.pmac.trajectory.velocities[number + 1].set(
+                self.pmac.trajectory.velocities[cs_index].set(
                     trajectory.velocities[motor]
                 )
             )
@@ -206,7 +205,7 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         for motor, position in ramp_up_position.items():
             coros.append(
                 set_and_wait_for_value(
-                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor] + 1],
+                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor]],
                     position,
                     set_timeout=10,
                     wait_for_set_completion=False,

ophyd_async/epics/pmac/_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import re
 from collections.abc import Sequence
 from dataclasses import dataclass
 
@@ -10,7 +11,7 @@ from scanspec.core import Slice
 from ophyd_async.core import gather_dict
 from ophyd_async.epics.motor import Motor
 
-from ._pmac_io import CS_LETTERS, PmacIO
+from ._pmac_io import CS_INDEX, PmacIO
 
 # PMAC durations are in milliseconds
 # We must convert from scanspec durations (seconds) to milliseconds
@@ -21,6 +22,11 @@ TICK_S = 0.000001
 MIN_TURNAROUND = 0.002
 MIN_INTERVAL = 0.002
 
+# Regex to parse outlink strings of the form "@asyn(PMAC1CS2, 7)"
+# returning PMAC1CS2 and 7
+# https://regex101.com/r/Mu9XpO/1
+OUTLINK_REGEX = re.compile(r"^\@asyn\(([^,]+),\s*(\d+)\)$")
+
 
 @dataclass
 class _PmacMotorInfo:
@@ -44,78 +50,115 @@ class _PmacMotorInfo:
             dictionaries of motor's to their unique CS index and accelerate rate
 
         """
-        assignments = {
-            motor: pmac.assignment[pmac.motor_assignment_index[motor]]
-            for motor in motors
-        }
-
-        cs_ports, cs_numbers, cs_axes, velocities, accls = await asyncio.gather(
-            gather_dict(
-                {motor: assignments[motor].cs_port.get_value() for motor in motors}
-            ),
-            gather_dict(
-                {motor: assignments[motor].cs_number.get_value() for motor in motors}
-            ),
-            gather_dict(
-                {
-                    motor: assignments[motor].cs_axis_letter.get_value()
-                    for motor in motors
-                }
-            ),
-            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
-            gather_dict(
-                {motor: motor.acceleration_time.get_value() for motor in motors}
-            ),
-        )
+        is_raw_motor = [motor in pmac.motor_assignment_index for motor in motors]
+        if all(is_raw_motor):
+            # Get the CS port, number and axis letter from the PVs for the raw motor
+            assignments = {
+                motor: pmac.assignment[pmac.motor_assignment_index[motor]]
+                for motor in motors
+            }
+            cs_ports, cs_numbers, cs_axis_letters = await asyncio.gather(
+                gather_dict(
+                    {motor: assignments[motor].cs_port.get_value() for motor in motors}
+                ),
+                gather_dict(
+                    {
+                        motor: assignments[motor].cs_number.get_value()
+                        for motor in motors
+                    }
+                ),
+                gather_dict(
+                    {
+                        motor: assignments[motor].cs_axis_letter.get_value()
+                        for motor in motors
+                    }
+                ),
+            )
+            # Translate axis letters to cs_index and check for duplicates
+            motor_cs_index: dict[Motor, int] = {}
+            for motor, cs_axis_letter in cs_axis_letters.items():
+                if not cs_axis_letter:
+                    raise ValueError(
+                        f"Motor {motor.name} does not have an axis assignment."
+                    )
+                try:
+                    # 1 indexed to match coord
+                    index = CS_INDEX[cs_axis_letter]
+                except KeyError as err:
+                    raise ValueError(
+                        f"Motor {motor.name} assigned to '{cs_axis_letter}' "
+                        f"but must be assigned to one of '{','.join(CS_INDEX)}'"
+                    ) from err
+                if index in motor_cs_index.values():
+                    raise ValueError(
+                        f"Motor {motor.name} assigned to '{cs_axis_letter}' "
+                        "but another motor is already assigned to this axis."
+                    )
+                motor_cs_index[motor] = index
+        elif not any(is_raw_motor):
+            # Get CS numbers from all the cs ports and output links for the CS motors
+            output_links, cs_lookup = await asyncio.gather(
+                gather_dict({motor: motor.output_link.get_value() for motor in motors}),
+                gather_dict(
+                    {
+                        cs_number: cs.cs_port.get_value()
+                        for cs_number, cs in pmac.coord.items()
+                    }
+                ),
+            )
+            # Create a reverse lookup from cs_port to cs_number
+            cs_reverse_lookup = {
+                cs_port: cs_number for cs_number, cs_port in cs_lookup.items()
+            }
+            cs_ports: dict[Motor, str] = {}
+            cs_numbers: dict[Motor, int] = {}
+            motor_cs_index: dict[Motor, int] = {}
+            # Populate the cs_ports, cs_numbers and motor_cs_index dicts from outlinks
+            for motor, output_link in output_links.items():
+                match = OUTLINK_REGEX.match(output_link)
+                if not match:
+                    raise ValueError(
+                        f"Motor {motor.name} has invalid output link '{output_link}'"
+                    )
+                cs_port, cs_index = match.groups()
+                cs_ports[motor] = cs_port
+                cs_numbers[motor] = cs_reverse_lookup[cs_port]
+                motor_cs_index[motor] = int(cs_index)
+        else:
+            raise ValueError("Unable to use raw motors and CS motors in the same scan")
 
         # check if the values in cs_port and cs_number are the same
-        cs_ports = set(cs_ports.values())
-
-        if len(cs_ports) != 1:
+        cs_ports_set = set(cs_ports.values())
+        if len(cs_ports_set) != 1:
             raise RuntimeError(
                 "Failed to fetch common CS port."
                 "Motors passed are assigned to multiple CS ports:"
-                f"{list(cs_ports)}"
+                f"{list(cs_ports_set)}"
             )
-
-        cs_port = cs_ports.pop()
-
-        cs_numbers = set(cs_numbers.values())
-        if len(cs_numbers) != 1:
+        cs_numbers_set = set(cs_numbers.values())
+        if len(cs_numbers_set) != 1:
             raise RuntimeError(
                 "Failed to fetch common CS number."
                 "Motors passed are assigned to multiple CS numbers:"
-                f"{list(cs_numbers)}"
+                f"{list(cs_numbers_set)}"
             )
 
-        cs_number = cs_numbers.pop()
-
-        motor_cs_index = {}
-        for motor in cs_axes:
-            try:
-                if not cs_axes[motor]:
-                    raise ValueError
-                motor_cs_index[motor] = CS_LETTERS.index(cs_axes[motor])
-            except ValueError as err:
-                raise ValueError(
-                    "Failed to get motor CS index. "
-                    f"Motor {motor.name} assigned to '{cs_axes[motor]}' "
-                    f"but must be assignmed to '{CS_LETTERS}"
-                ) from err
-            if len(set(motor_cs_index.values())) != len(motor_cs_index.items()):
-                raise RuntimeError(
-                    "Failed to fetch distinct CS Axes."
-                    "Motors passed are assigned to the same CS Axis"
-                    f"{list(motor_cs_index)}"
-                )
-
+        # Get the velocities and acceleration rates for each motor
+        max_velocity, acceleration_time = await asyncio.gather(
+            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
+            gather_dict(
+                {motor: motor.acceleration_time.get_value() for motor in motors}
+            ),
+        )
         motor_acceleration_rate = {
-            motor: float(velocities[motor]) / float(accls[motor])
-            for motor in velocities
+            motor: max_velocity[motor] / acceleration_time[motor] for motor in motors
         }
-
         return _PmacMotorInfo(
-            cs_port, cs_number, motor_cs_index, motor_acceleration_rate, velocities
+            cs_port=cs_ports_set.pop(),
+            cs_number=cs_numbers_set.pop(),
+            motor_cs_index=motor_cs_index,
+            motor_acceleration_rate=motor_acceleration_rate,
+            motor_max_velocity=max_velocity,
         )
 
 

ophyd_async/tango/core/__init__.py

@@ -8,7 +8,6 @@ from ._signal import (
     tango_signal_w,
     tango_signal_x,
 )
-from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
@@ -50,7 +49,6 @@ __all__ = [
     "tango_signal_w",
     "tango_signal_x",
     "TangoDevice",
-    "TangoReadable",
     "TangoPolling",
     "TangoDeviceConnector",
     "TangoLongStringTable",

ophyd_async/tango/core/_base_device.py

@@ -29,7 +29,7 @@ class TangoDevice(Device):
 
     def __init__(
         self,
-        trl: str | None,
+        trl: str = "",
         support_events: bool = False,
         name: str = "",
         auto_fill_signals: bool = True,
@@ -80,6 +80,9 @@ class TangoDeviceConnector(DeviceConnector):
         self._support_events = support_events
         self._auto_fill_signals = auto_fill_signals
 
+    def set_trl(self, trl: str):
+        self.trl = trl
+
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
             self.filler = DeviceFiller(

ophyd_async/tango/demo/_counter.py

@@ -1,11 +1,18 @@
 from typing import Annotated as A
 
-from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+)
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango.core import TangoPolling, TangoReadable
+from ophyd_async.tango.core import TangoDevice, TangoPolling
 
 
-class TangoCounter(TangoReadable):
+class TangoCounter(TangoDevice, StandardReadable):
     """Tango counting device."""
 
     # Enter the name and type of the signals you want to use

ophyd_async/tango/demo/_mover.py

@@ -11,16 +11,17 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     SignalX,
+    StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango.core import DevStateEnum, TangoPolling, TangoReadable
+from ophyd_async.tango.core import DevStateEnum, TangoDevice, TangoPolling
 
 
-class TangoMover(TangoReadable, Movable, Stoppable):
+class TangoMover(TangoDevice, StandardReadable, Movable, Stoppable):
     """Tango moving device."""
 
     # Enter the name and type of the signals you want to use
@@ -32,7 +33,7 @@ class TangoMover(TangoReadable, Movable, Stoppable):
     # If a tango name clashes with a bluesky verb, add a trailing underscore
     stop_: SignalX
 
-    def __init__(self, trl: str | None = "", name=""):
+    def __init__(self, trl: str = "", name=""):
         super().__init__(trl, name=name)
         self.add_readables([self.position], Format.HINTED_SIGNAL)
         self.add_readables([self.velocity], Format.CONFIG_SIGNAL)

{ophyd_async-0.13.6.dist-info → ophyd_async-0.13.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.6
+Version: 0.13.7
 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.13.6.dist-info → ophyd_async-0.13.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
 ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
-ophyd_async/_version.py,sha256=opPR5vtgMqtAtI-1B5Bg_MEreSc0tb9JwaQhHrD7xNE,706
+ophyd_async/_version.py,sha256=JHUU2H4LQG4g5yLVtdeoRqh4fKkn1TUpLvJEVN4qjr4,706
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/core/__init__.py,sha256=yGbkVju5otO8DmA3KyerYB0gLtcX5sdxlq3ajyGha4M,5531
 ophyd_async/core/_derived_signal.py,sha256=TuZza_j3J1Bw4QSqBYB9Ta2FyQP5BycO3nSHVtJ890Q,13015
@@ -18,7 +18,7 @@ ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU
 ophyd_async/core/_providers.py,sha256=WBht3QCgvGc0stNcwH6z4Zr6hAz3e01-88NjsYI2w6I,9740
 ophyd_async/core/_readable.py,sha256=iBo1YwA5bsAbzLbznvmSnzKDWUuGkLh850Br3BXsgeU,11707
 ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
-ophyd_async/core/_signal.py,sha256=085vcyjhEyZECi4Svjq6DUM5kxrzZh8s5DoHR2LALOc,28195
+ophyd_async/core/_signal.py,sha256=LVQ38-Txn6lIYFsIbRbZClOy9WXlLDc16FdaE1wVmII,28278
 ophyd_async/core/_signal_backend.py,sha256=F3ma45cIIJ3D702zsVZIqn4Jv7u05YzMQBQND70QCbQ,6987
 ophyd_async/core/_soft_signal_backend.py,sha256=NJUuyaCKtBZjggt8WKi7_lKQRHasToxviuQvl5xbhLU,6222
 ophyd_async/core/_status.py,sha256=a2IDvv_GvUcFuhjQA5bQzWm9ngR6zGc9PR4XcZiaeqk,6557
@@ -26,7 +26,7 @@ ophyd_async/core/_table.py,sha256=ryJ7AwJBglQUzwP9_aSjR8cu8EKvYXfo1q1byhke3Uc,72
 ophyd_async/core/_utils.py,sha256=gUewO4XPrBxsEWzObNumqAB2Q7Hwrd5F_Nc6B2XwQIM,12532
 ophyd_async/core/_yaml_settings.py,sha256=Qojhku9l5kPSkTnEylCRWTe0gpw6S_XP5av5dPpqFgQ,2089
 ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
-ophyd_async/epics/motor.py,sha256=nS6Vx4-6vYso3b_QtpE8p8dlys5jRr2LK7prZCkZMc8,9558
+ophyd_async/epics/motor.py,sha256=RDcyKC_zFR5zLpAcf_yAbuY-1ImE3L3uBAoUXDEiz-s,10224
 ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
 ophyd_async/epics/adandor/__init__.py,sha256=dlitllrAdhvh16PAcVMUSSEytTDNMu6_HuYk8KD1EoY,343
 ophyd_async/epics/adandor/_andor.py,sha256=TijGjNVxuH-P0X7UACPt9eLLQ449DwMyVhbn1kV7Le8,1245
@@ -83,10 +83,10 @@ ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1n
 ophyd_async/epics/odin/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
 ophyd_async/epics/odin/_odin_io.py,sha256=YDBrS15PnEKe5SHmz397Emh--lZSQEnbR3G7p8pbShY,6533
 ophyd_async/epics/pmac/__init__.py,sha256=GqJTiJudqE9pu050ZNED09F9tKRfazn0wBsojsMH2gg,273
-ophyd_async/epics/pmac/_pmac_io.py,sha256=E7tdaq9FAM6BeGQG1L8ALEYpXOlyqTXl_NLLSWzmCdk,4345
-ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=7wTaetNNy9uj7C_skcs0VH5BthuY4Ec5zn-m4ROxd8k,7866
+ophyd_async/epics/pmac/_pmac_io.py,sha256=cbChieNrDWRzrr5Mdsqtm2Azp8sG0KHP9rGeJxmbYrA,4332
+ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=hzAcpLNmFoNceubsjk6mjsmg6-PgSjWUu1a8Exyvi6I,7729
 ophyd_async/epics/pmac/_pmac_trajectory_generation.py,sha256=3IIxXa0r6-2uNnILKLGxp3xosOZx8MubKF-F_OM7uaw,27331
-ophyd_async/epics/pmac/_utils.py,sha256=n4vh9n7hmaWe9g02FtguF2oDsYuVvsTgmK7fYEyGuIE,6092
+ophyd_async/epics/pmac/_utils.py,sha256=MfuY6NicT7wkwVIWAZkWoCu1ZoSzy6jda1wLK9XAOLA,8614
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
 ophyd_async/epics/testing/_example_ioc.py,sha256=zb4ZEUzuB2MrSw5ETPLIiHhf-2BRU1Bdxco6Kh4iI1I,3880
 ophyd_async/epics/testing/_utils.py,sha256=9gxpwaWX0HGtacu1LTupcw7viXN8G78RmuNciU_-cjs,1702
@@ -131,17 +131,16 @@ ophyd_async/sim/_pattern_generator.py,sha256=kuxvyX2gIxrywhQRhaO1g8YluBT7LBkE20I
 ophyd_async/sim/_point_detector.py,sha256=wMG_ncvm99WMCPihlFyuMEf3UknAxCpB1hpk3uKiENE,3024
 ophyd_async/sim/_stage.py,sha256=_SywbmSQwxf7JLx68qwo0RpiB3oIWlbTLmvRKxUoig0,1602
 ophyd_async/tango/__init__.py,sha256=g9xzjlzPpUAP12YI-kYwfAoLSYPAQdL1S11R2c-cius,60
-ophyd_async/tango/core/__init__.py,sha256=OOVdHu07cssK90F-caG0CY7qKpPYy0MSV421YNAI-_8,1413
-ophyd_async/tango/core/_base_device.py,sha256=e9oqSL-fDOj8r9nUUFZkbibhRGbI6HYtlnZjK5B_2fE,5033
+ophyd_async/tango/core/__init__.py,sha256=dO2tG_y61zZFQRQh5L37Ps-IqNf-DGOT77Ov5Kobfhs,1349
+ophyd_async/tango/core/_base_device.py,sha256=X5ncxaWKOfRhhqPyT8tmTBJGc3ldGthw1ZCe_j_M2Tg,5088
 ophyd_async/tango/core/_converters.py,sha256=xI_RhMR8dY6IVORUZVVCL9LdYnEE6TA6BBPX_lTu06w,2183
 ophyd_async/tango/core/_signal.py,sha256=8mIxRVEVjhDN33LDbbKZWGMUYn9Gl5ZMEIYw6GSBTUE,5569
-ophyd_async/tango/core/_tango_readable.py,sha256=ctR6YcBGGatW6Jp2kvddA1hVZ2v1CidPsF9FmJK9BYg,406
 ophyd_async/tango/core/_tango_transport.py,sha256=KxjhHqKADrOvzGi9tbOQXUWdsJ0NKGejWxHItxpUsjg,37401
 ophyd_async/tango/core/_utils.py,sha256=pwT7V1DNWSyPOSzvDZ6OsDZTjaV-pAeDLDlmgtHVcNM,1673
 ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
-ophyd_async/tango/demo/_counter.py,sha256=2J4SCHnBWLF0O5mFWlJdO4tmnElvlx5sRrk4op_AC9U,1139
+ophyd_async/tango/demo/_counter.py,sha256=m6zxOJLbHgCEBAapVc1UiOOqKj5lvrlxjA6mXWMRMjo,1200
 ophyd_async/tango/demo/_detector.py,sha256=X5YWHAjukKZ7iYF1fBNle4CBDj1X5rvj0lnPMOcnRCU,1340
-ophyd_async/tango/demo/_mover.py,sha256=i-Tq5nDmYi4RcC4O6mOJoVeMEIIxuqyS_2AfjTpAcnk,2884
+ophyd_async/tango/demo/_mover.py,sha256=FyG9g1TLaWoqjbLblqWK8inMuDcNVlioq0MIeD5npz4,2913
 ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
 ophyd_async/tango/demo/_tango/_servers.py,sha256=putvERDyibibaTbhdWyqZB_axj2fURXqzDsZb9oSW14,2991
 ophyd_async/tango/testing/__init__.py,sha256=l52SmX9XuxZUBuLpOYJzHfskkWVYhx3RkSbGL_wUu5Y,199
@@ -155,8 +154,8 @@ ophyd_async/testing/_one_of_everything.py,sha256=U9ui7B-iNHDM3H3hIWUuaCb8Gc2eLlU
 ophyd_async/testing/_single_derived.py,sha256=5-HOTzgePcZ354NK_ssVpyIbJoJmKyjVQCxSwQXUC-4,2730
 ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.13.6.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.13.6.dist-info/METADATA,sha256=o3yNVUgIIR1UiWECtmQX9WZLuZAu4et3sru1DKoOsDM,5703
-ophyd_async-0.13.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.13.6.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.13.6.dist-info/RECORD,,
+ophyd_async-0.13.7.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.13.7.dist-info/METADATA,sha256=D28G3xy4fiF7xtLVoy10CqOiI7ZLDs2z1MO6DICwVdA,5703
+ophyd_async-0.13.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.13.7.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.13.7.dist-info/RECORD,,

ophyd_async/tango/core/_tango_readable.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from ophyd_async.core import StandardReadable
-
-from ._base_device import TangoDevice
-
-
-class TangoReadable(TangoDevice, StandardReadable):
-    def __init__(
-        self,
-        trl: str | None = None,
-        name: str = "",
-        auto_fill_signals: bool = True,
-    ) -> None:
-        TangoDevice.__init__(self, trl, name=name, auto_fill_signals=auto_fill_signals)