ophyd-async 0.13.6__tar.gz → 0.13.7__tar.gz

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/.devcontainer/devcontainer.json

@@ -16,7 +16,9 @@
         "UV_PROJECT_ENVIRONMENT": "/cache/venv-for${localWorkspaceFolder}",
         // Do the equivalent of "activate" the venv so we don't have to "uv run" everything
         "VIRTUAL_ENV": "/cache/venv-for${localWorkspaceFolder}",
-        "PATH": "/cache/venv-for${localWorkspaceFolder}/bin:${containerEnv:PATH}"
+        "PATH": "/cache/venv-for${localWorkspaceFolder}/bin:${containerEnv:PATH}",
+        // Help external service fixtures match docker compose working directory with the host
+        "EXAMPLE_SERVICES_PATH": "${localWorkspaceFolder}/example-services"
     },
     "customizations": {
         "vscode": {
@@ -58,7 +60,9 @@
         // Allow the container to access the host X11 display and EPICS CA
         "--net=host",
         // Make sure SELinux does not disable with access to host filesystems like tmp
-        "--security-opt=label=disable"
+        "--security-opt=label=disable",
+        // add the docker socket environment variable to the container
+        "-e=DOCKER_HOST=${localEnv:DOCKER_HOST}"
     ],
     "mounts": [
         // Mount in the user terminal config folder so it can be edited
@@ -72,6 +76,18 @@
             "source": "devcontainer-shared-cache",
             "target": "/cache",
             "type": "volume"
+        },
+        // Match host external services file paths (internal docker starts them on the host)
+        {
+            "source": "${localWorkspaceFolder}/example-services",
+            "target": "${localWorkspaceFolder}/example-services",
+            "type": "bind"
+        },
+        // Mount the user sockets folder
+        {
+            "source": "${localEnv:XDG_RUNTIME_DIR}",
+            "target": "${localEnv:XDG_RUNTIME_DIR}",
+            "type": "bind"
         }
     ],
     // Mount the parent as /workspaces so we can pip install peers as editable

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/.github/workflows/_test.yml

@@ -13,10 +13,6 @@ on:
         type: string
         description: The path to look for tests
         required: true
-      needs-services:
-        type: boolean
-        description: Whether to start external services
-        required: true
     secrets:
       CODECOV_TOKEN:
         required: true
@@ -32,6 +28,7 @@ jobs:
 
     env:
       COVERAGE_PROCESS_START: .coveragerc
+      EXAMPLE_SERVICES_PATH: ./example-services
 
     steps:
       - name: Checkout repository (with submodules)
@@ -49,15 +46,6 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v7
 
-      - if: inputs.needs-services && inputs.runs-on != 'windows-latest'
-        name: Run docker compose
-        uses: hoverkraft-tech/compose-action@v2.4.1
-        with:
-          compose-file: "./example-services/compose.yaml"
-          services: |
-            bl01t-di-cam-01
-            ca-gateway
-
       - name: Run tests win
         if: inputs.runs-on == 'windows-latest'
         run: uv run --locked tox -e tests -- --timeout=10 ${{ inputs.tests-path}}

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/.github/workflows/ci.yml

@@ -19,18 +19,13 @@ jobs:
       matrix:
         runs-on: ["ubuntu-latest", "windows-latest"] # can add macos-latest
         python-version: ["3.11", "3.12", "3.13"]
-        test-config:
-          - tests-path: "tests/unit_tests"
-            needs-services: false
-          - tests-path: "tests/system_tests"
-            needs-services: true
+        tests-path: ["", "tests/system_tests"]
       fail-fast: false
     uses: ./.github/workflows/_test.yml
     with:
       runs-on: ${{ matrix.runs-on }}
       python-version: ${{ matrix.python-version }}
-      tests-path: ${{ matrix.test-config.tests-path }}
-      needs-services: ${{ matrix.test-config.needs-services }}
+      tests-path: ${{ matrix.tests-path }}
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 

ophyd_async-0.13.7/Dockerfile

@@ -0,0 +1,25 @@
+# The devcontainer should use the developer target and run as root with podman
+# or docker with user namespaces.
+FROM ghcr.io/diamondlightsource/ubuntu-devcontainer:noble AS developer
+
+ENV DOCKER=docker-28.5.1
+ENV DOCKER_COMPOSE_RELEASE_TAG=v2.40.3
+
+# Add any system dependencies for the developer/build environment here
+RUN apt-get update -y && apt-get install -y --no-install-recommends \
+    graphviz \
+    libxcb-cursor0 \
+    qt6-base-dev \
+    curl \
+    && apt-get dist-clean
+
+# install the docker ce cli binary
+RUN curl -O https://download.docker.com/linux/static/stable/x86_64/${DOCKER}.tgz && \
+    tar xvf ${DOCKER}.tgz && \
+    cp docker/docker /usr/bin && \
+    rm -r ${DOCKER}.tgz docker
+
+# install docker-compose plugin
+RUN mkdir -p /usr/libexec/docker/cli-plugins/ && \
+    curl -SL https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_RELEASE_TAG}/docker-compose-linux-x86_64 -o /usr/libexec/docker/cli-plugins/docker-compose && \
+    chmod +x /usr/libexec/docker/cli-plugins/docker-compose

{ophyd_async-0.13.6/src/ophyd_async.egg-info → ophyd_async-0.13.7}/PKG-INFO

@@ -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 → ophyd_async-0.13.7}/docs/conf.py

@@ -206,7 +206,6 @@ intersphinx_mapping = {
     "bluesky": ("https://blueskyproject.io/bluesky/main", None),
     "scanspec": ("https://blueskyproject.io/scanspec/main", None),
     "numpy": ("https://numpy.org/devdocs/", None),
-    "databroker": ("https://blueskyproject.io/databroker/", None),
     "event-model": ("https://blueskyproject.io/event-model/main", None),
     "pytest": ("https://docs.pytest.org/en/stable/", None),
 }

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/src/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 = 'g13f67ee23'
+__commit_id__ = commit_id = 'g80ae4488a'

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.7/src/ophyd_async/epics/pmac/_utils.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import asyncio
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+from scanspec.core import Slice
+
+from ophyd_async.core import gather_dict
+from ophyd_async.epics.motor import Motor
+
+from ._pmac_io import CS_INDEX, PmacIO
+
+# PMAC durations are in milliseconds
+# We must convert from scanspec durations (seconds) to milliseconds
+# PMAC motion program multiples durations by 0.001
+# (see https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmc/trajectory_scan_code_ppmac.pmc#L241)
+# Therefore, we must divide scanspec durations by 10e-6
+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:
+    cs_port: str
+    cs_number: int
+    motor_cs_index: dict[Motor, int]
+    motor_acceleration_rate: dict[Motor, float]
+    motor_max_velocity: dict[Motor, float]
+
+    @classmethod
+    async def from_motors(cls, pmac: PmacIO, motors: Sequence[Motor]) -> _PmacMotorInfo:
+        """Creates a _PmacMotorInfo instance based on a  controller and list of motors.
+
+        :param pmac: The PMAC device
+        :param motors: Sequence of motors involved in trajectory
+        :raises RuntimeError:
+            if motors do not share common CS port or CS number, or if
+            motors do not have unique CS index assignments
+        :returns:
+            _PmacMotorInfo instance with motor's common CS port and CS number, and
+            dictionaries of motor's to their unique CS index and accelerate rate
+
+        """
+        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 = 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_set)}"
+            )
+        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_set)}"
+            )
+
+        # 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: max_velocity[motor] / acceleration_time[motor] for motor in motors
+        }
+        return _PmacMotorInfo(
+            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,
+        )
+
+
+def calculate_ramp_position_and_duration(
+    slice: Slice[Motor], motor_info: _PmacMotorInfo, is_up: bool
+) -> tuple[dict[Motor, np.float64], float]:
+    """Calculate the the required ramp position and duration of a trajectory.
+
+    This function will:
+      - Calculate the ramp time required to achieve each motor's
+        initial entry velocity into the first frame of a slice
+        or final exit velocity out of the last frame of a slice
+      - Use the longest ramp time to calculate all motor's
+        ramp up positions.
+
+    :param slice: Information about a series of scan frames along a number of axes
+    :param motor_info: Instance of _PmacMotorInfo
+    :param is_up: Boolean representing ramping up into a frame or down out of a frame
+    :returns tuple: A tuple containing:
+        dict: Motor to ramp positions
+        float: Ramp time required for all motors
+    """
+    if slice.duration is None:
+        raise ValueError("Slice must have a duration")
+
+    scan_axes = slice.axes()
+    idx = 0 if is_up else -1
+
+    velocities: dict[Motor, float] = {}
+    ramp_times: list[float] = []
+    for axis in scan_axes:
+        velocity = (slice.upper[axis][idx] - slice.lower[axis][idx]) / slice.duration[
+            idx
+        ]
+        velocities[axis] = velocity
+        ramp_times.append(abs(velocity) / motor_info.motor_acceleration_rate[axis])
+    ramp_times.append(
+        MIN_TURNAROUND
+    )  # Adding a 2ms ramp time as a min tournaround time
+    max_ramp_time = max(ramp_times)
+
+    motor_to_ramp_position = {}
+    sign = -1 if is_up else 1
+    for axis, v in velocities.items():
+        ref_pos = slice.lower[axis][0] if is_up else slice.upper[axis][-1]
+        displacement = 0.5 * v * max_ramp_time
+        motor_to_ramp_position[axis] = ref_pos + sign * displacement
+
+    return (motor_to_ramp_position, max_ramp_time)

{ophyd_async-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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-0.13.6 → ophyd_async-0.13.7}/src/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 → ophyd_async-0.13.7/src/ophyd_async.egg-info}/PKG-INFO

@@ -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 → ophyd_async-0.13.7}/src/ophyd_async.egg-info/SOURCES.txt

@@ -216,7 +216,6 @@ src/ophyd_async/tango/core/__init__.py
 src/ophyd_async/tango/core/_base_device.py
 src/ophyd_async/tango/core/_converters.py
 src/ophyd_async/tango/core/_signal.py
-src/ophyd_async/tango/core/_tango_readable.py
 src/ophyd_async/tango/core/_tango_transport.py
 src/ophyd_async/tango/core/_utils.py
 src/ophyd_async/tango/demo/__init__.py
@@ -238,10 +237,10 @@ src/ophyd_async/testing/_utils.py
 src/ophyd_async/testing/_wait_for_pending.py
 tests/README.md
 tests/conftest.py
+tests/system_tests/conftest.py
 tests/system_tests/test_tutorials.py
 tests/system_tests/epics/adsim/baseline.yaml
-tests/system_tests/epics/adsim/start_iocs.sh
-tests/system_tests/epics/adsim/stop_iocs.sh
+tests/system_tests/epics/adsim/external_dependencies.sh
 tests/system_tests/epics/adsim/test_adsim_system.py
 tests/system_tests/epics/eiger/README.md
 tests/system_tests/epics/eiger/start_iocs_and_run_tests.sh