ophyd-async 0.14.0__tar.gz → 0.14.2__tar.gz

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/.copier-answers.yml

@@ -1,5 +1,5 @@
 # Changes here will be overwritten by Copier
-_commit: 5.0.0a5
+_commit: 5.0.1
 _src_path: https://github.com/DiamondLightSource/python-copier-template
 author_email: tom.cobb@diamond.ac.uk
 author_name: Tom Cobb

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/.github/CONTRIBUTING.md

@@ -24,4 +24,4 @@ It is recommended that developers use a [vscode devcontainer](https://code.visua
 
 This project was created using the [Diamond Light Source Copier Template](https://github.com/DiamondLightSource/python-copier-template) for Python projects.
 
-For more information on common tasks like setting up a developer environment, running the tests, and setting a pre-commit hook, see the template's [How-to guides](https://diamondlightsource.github.io/python-copier-template/5.0.0a5/how-to.html).
+For more information on common tasks like setting up a developer environment, running the tests, and setting a pre-commit hook, see the template's [How-to guides](https://diamondlightsource.github.io/python-copier-template/5.0.1/how-to.html).

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/.github/workflows/_test.yml

@@ -13,9 +13,6 @@ on:
         type: string
         description: The path to look for tests
         required: true
-    secrets:
-      CODECOV_TOKEN:
-        required: true
 
 env:
   # https://github.com/pytest-dev/pytest/issues/2042
@@ -59,5 +56,3 @@ jobs:
         with:
           name: ${{ inputs.python-version }}/${{ inputs.runs-on }}/${{ inputs.tests-path }}
           files: cov.xml
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/.github/workflows/ci.yml

@@ -20,14 +20,16 @@ jobs:
         runs-on: ["ubuntu-latest", "windows-latest"] # can add macos-latest
         python-version: ["3.11", "3.12", "3.13"]
         tests-path: ["", "tests/system_tests"]
+        include:
+          - runs-on: "ubuntu-latest"
+            python-version: "3.11"
+            tests-path: "tests/system_tests_tango"
       fail-fast: false
     uses: ./.github/workflows/_test.yml
     with:
       runs-on: ${{ matrix.runs-on }}
       python-version: ${{ matrix.python-version }}
       tests-path: ${{ matrix.tests-path }}
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   docs:
     uses: ./.github/workflows/_docs.yml

ophyd_async-0.14.2/.github/workflows/claude.yml

@@ -0,0 +1,52 @@
+name: Claude PR Comment Review
+# https://github.com/anthropics/claude-code-action/blob/main/docs/solutions.md#automatic-pr-code-review
+# https://skywork.ai/blog/how-to-use-claude-code-for-prs-code-reviews-guide/#step-3-add-a-comment-triggered-workflow-copy-pasteable
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  review:
+    if: ${{ contains(github.event.comment.body, '@claude') && github.event.issue.pull_request != null }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 1
+
+      - run: find
+
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          track_progress: true # ✨ Enables tracking comments
+          prompt: |
+            REPO: ${{ github.repository }}
+            PR NUMBER: ${{ github.event.issue.number }}
+
+            Please review this pull request with a focus on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Security implications
+            - Performance considerations
+
+            Note: The PR branch is already checked out in the current working directory.
+
+            Make sure to:
+            - Use `gh pr comment` for concise top-level feedback
+            - Use `mcp__github_inline_comment__create_inline_comment` to highlight specific code issues
+            - Put all detailed feedback and recommendations in inline comments and do not duplicate in the main PR comment
+            - Anywhere you have a line number reference, use an inline comment
+            - Check structure is consist with existing code style
+            - Skip style issues already handled by linters
+            - Check for duplication of code already in the repository; aim for re-use where sensible
+            - Favour composition over inheritence
+            - Respond in concise bullet point form; avoid restating code
+
+          claude_args: |
+            --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)"

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/.pre-commit-config.yaml

@@ -3,7 +3,7 @@ repos:
     rev: v5.0.0
     hooks:
       - id: check-added-large-files
-        args: ["--maxkb=1000"] # uv.lock is more than 500kB
+        exclude: ^uv.lock
       - id: check-yaml
       - id: check-merge-conflict
       - id: end-of-file-fixer

{ophyd_async-0.14.0/src/ophyd_async.egg-info → ophyd_async-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.14.0
+Version: 0.14.2
 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.14.0 → ophyd_async-0.14.2}/src/ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.14.0'
-__version_tuple__ = version_tuple = (0, 14, 0)
+__version__ = version = '0.14.2'
+__version_tuple__ = version_tuple = (0, 14, 2)
 
-__commit_id__ = commit_id = 'g3da44d6fb'
+__commit_id__ = commit_id = 'ga221add53'

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/core/__init__.py

@@ -48,6 +48,7 @@ from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable, Watcher
 from ._providers import (
     AutoIncrementFilenameProvider,
     AutoIncrementingPathProvider,
+    AutoMaxIncrementingPathProvider,
     DatasetDescriber,
     FilenameProvider,
     PathInfo,
@@ -222,6 +223,7 @@ __all__ = [
     "FilenameProvider",
     "StaticFilenameProvider",
     "AutoIncrementFilenameProvider",
+    "AutoMaxIncrementingPathProvider",
     "UUIDFilenameProvider",
     # Datatset
     "DatasetDescriber",

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/core/_derived_signal.py

@@ -1,5 +1,15 @@
-from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_args, get_origin, get_type_hints, is_typeddict
+import functools
+from collections.abc import Awaitable, Callable, Mapping
+from inspect import Parameter, signature
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    get_args,
+    get_origin,
+    get_type_hints,
+    is_typeddict,
+)
 
 from bluesky.protocols import Locatable
 
@@ -53,12 +63,13 @@ class DerivedSignalFactory(Generic[TransformT]):
             # Populate expected parameters and types
             expected = {
                 **{k: f.annotation for k, f in transform_cls.model_fields.items()},
-                **{
-                    k: v
-                    for k, v in get_type_hints(transform_cls.raw_to_derived).items()
-                    if k not in {"self", "return"}
-                },
+                **_get_params_types_dict(transform_cls.raw_to_derived),
             }
+            if empty_keys := [k for k, v in expected.items() if v == Parameter.empty]:
+                raise TypeError(
+                    f"{transform_cls.raw_to_derived} is missing a type "
+                    f"hint for arguments: {empty_keys}"
+                )
 
             # Populate received parameters and types
             # Use Primitive's type, Signal's datatype,
@@ -76,7 +87,19 @@ class DerivedSignalFactory(Generic[TransformT]):
                     f"Expected the following to be passed as keyword arguments "
                     f"{expected}, got {received}"
                 )
-                raise TypeError(msg)
+                if set(expected.keys()) - set(received.keys()):
+                    raise TypeError(msg)
+
+                for k in set(expected.keys()):
+                    if isinstance(expected[k], type):
+                        if not issubclass(received[k], expected[k]):
+                            raise TypeError(msg)
+                    elif isinstance(expected[k], TypeVar):
+                        bound = expected[k].__bound__
+                        if isinstance(bound, type) and not issubclass(
+                            received[k], bound
+                        ):
+                            raise TypeError(msg)
         self._set_derived_takes_dict = (
             is_typeddict(_get_first_arg_datatype(set_derived)) if set_derived else False
         )
@@ -195,28 +218,28 @@ def _get_return_datatype(func: Callable[..., SignalDatatypeT]) -> type[SignalDat
 def _get_first_arg_datatype(
     func: Callable[[SignalDatatypeT], Any],
 ) -> type[SignalDatatypeT]:
-    args = get_type_hints(func)
-    args.pop("return", None)
+    args = _get_params_types_dict(func)
     if not args:
         msg = f"{func} does not have a type hinted argument"
         raise TypeError(msg)
     return list(args.values())[0]
 
 
+def _get_params_types_dict(inspected_function: Callable) -> Mapping[str, Any]:
+    sig = signature(inspected_function, eval_str=True)
+    exclude_keys = {"self", "args", "kwargs", "cls"}
+    return {k: v.annotation for k, v in sig.parameters.items() if k not in exclude_keys}
+
+
 def _make_factory(
-    raw_to_derived: Callable[..., SignalDatatypeT] | None = None,
+    raw_to_derived_func: Callable[..., SignalDatatypeT] | None = None,
     set_derived: Callable[[SignalDatatypeT], Awaitable[None]] | None = None,
     raw_devices_and_constants: dict[str, Device | Primitive] | None = None,
 ) -> DerivedSignalFactory:
-    if raw_to_derived:
+    if raw_to_derived_func:
 
         class DerivedTransform(Transform):
-            def raw_to_derived(self, **kwargs) -> dict[str, SignalDatatypeT]:
-                return {"value": raw_to_derived(**kwargs)}
-
-        # Update the signature for raw_to_derived to match what we are passed as this
-        # will be checked in DerivedSignalFactory
-        DerivedTransform.raw_to_derived.__annotations__ = get_type_hints(raw_to_derived)
+            raw_to_derived = _dict_wrapper(raw_to_derived_func)
 
         return DerivedSignalFactory(
             DerivedTransform,
@@ -245,7 +268,7 @@ def derived_signal_r(
         The names of these arguments must match the arguments of raw_to_derived.
     """
     factory = _make_factory(
-        raw_to_derived=raw_to_derived,
+        raw_to_derived_func=raw_to_derived,
         raw_devices_and_constants=raw_devices_and_constants,
     )
     return factory.derived_signal_r(
@@ -278,16 +301,16 @@ def derived_signal_rw(
         The names of these arguments must match the arguments of raw_to_derived.
     """
     raw_to_derived_datatype = _get_return_datatype(raw_to_derived)
-    set_derived_datatype = _get_first_arg_datatype(set_derived)
-    if raw_to_derived_datatype != set_derived_datatype:
+    set_derived_arg_datatype = _get_first_arg_datatype(set_derived)
+    if raw_to_derived_datatype != set_derived_arg_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
+            f"!= {set_derived_arg_datatype} datatype {set_derived_arg_datatype}"
         )
         raise TypeError(msg)
 
     factory = _make_factory(
-        raw_to_derived=raw_to_derived,
+        raw_to_derived_func=raw_to_derived,
         set_derived=set_derived,
         raw_devices_and_constants=raw_devices_and_constants,
     )
@@ -343,3 +366,13 @@ def _partition_by_keys(data: dict, keys: set) -> tuple[dict, dict]:
         else:
             group_excluded[k] = v
     return group_excluded, group_included
+
+
+def _dict_wrapper(
+    fn: Callable[..., SignalDatatypeT],
+) -> Callable[..., dict[str, SignalDatatypeT]]:
+    @functools.wraps(fn)
+    def wrapped(self, **kwargs):
+        return {"value": fn(**kwargs)}
+
+    return wrapped

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/core/_device_filler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import types
 from abc import abstractmethod
 from collections.abc import Callable, Iterator, Sequence
 from typing import (
@@ -9,8 +10,10 @@ from typing import (
     NoReturn,
     Protocol,
     TypeVar,
+    Union,
     cast,
     get_args,
+    get_origin,
     get_type_hints,
     runtime_checkable,
 )
@@ -76,6 +79,7 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
         self._extras: dict[UniqueName, Sequence[Any]] = {}
         self._signal_datatype: dict[LogicalName, type | None] = {}
         self._vector_device_type: dict[LogicalName, type[Device] | None] = {}
+        self._optional_devices: set[str] = set()
         self.ignored_signals: set[str] = set()
         # Backends and Connectors stored ready for the connection phase
         self._unfilled_backends: dict[
@@ -121,6 +125,20 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
                 self.ignored_signals.add(attr_name)
             name = UniqueName(attr_name)
             origin = get_origin_class(annotation)
+            args = get_args(annotation)
+
+            if (
+                get_origin(annotation) is Union
+                and types.NoneType in args
+                and len(args) == 2
+            ):
+                # Annotation is an Union with two arguments, one of which is None
+                # Make this signal an optional parameter and set origin to T
+                # so the device is added to unfilled_connectors
+                self._optional_devices.add(name)
+                (annotation,) = [x for x in args if x is not types.NoneType]
+                origin = get_origin_class(annotation)
+
             if (
                 name == "parent"
                 or name.startswith("_")
@@ -241,10 +259,17 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
         :param source: The source of the data that should have done the filling, for
                        reporting as an error message
         """
-        unfilled = sorted(set(self._unfilled_connectors).union(self._unfilled_backends))
-        if unfilled:
+        unfilled = set(self._unfilled_connectors).union(self._unfilled_backends)
+        unfilled_optional = sorted(unfilled.intersection(self._optional_devices))
+
+        for name in unfilled_optional:
+            setattr(self._device, name, None)
+
+        required = sorted(unfilled.difference(unfilled_optional))
+
+        if required:
             raise RuntimeError(
-                f"{self._device.name}: cannot provision {unfilled} from {source}"
+                f"{self._device.name}: cannot provision {required} from {source}"
             )
 
     def _ensure_device_vector(self, name: LogicalName) -> DeviceVector:

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/core/_providers.py

@@ -1,9 +1,10 @@
+import re
 import uuid
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import date
-from pathlib import PurePath, PureWindowsPath
+from pathlib import Path, PurePath, PureWindowsPath
 from typing import Protocol
 from urllib.parse import urlunparse
 
@@ -157,6 +158,98 @@ class StaticPathProvider(PathProvider):
         )
 
 
+class AutoMaxIncrementingPathProvider(PathProvider):
+    """Increment directory name on each call by checking existing directories.
+
+    Looks through directories in a specified base path to increment directory name.
+    PathInfo gives path like base_path/0001_dirname/dirname, or
+    base_path/yyyy-mm-dd/0001_dirname/dirname if dated is true. Here,
+    the '0001' is the value which gets incremented if the file exists already.
+
+    It's recommended for the base path provider to be non-incrementing.
+
+    Args:
+    base_path_provider: Path to create directories inside of. Note that the filename of
+    this provider is used as the top level directory and the filename
+    max_digits: Number of digits to pad onto the parent directory.
+    starting_value: Number to start incrementing from.
+    dated: Whether to create an extra directory to specify the day.
+
+    """
+
+    def __init__(
+        self,
+        base_path_provider: PathProvider,
+        max_digits: int = 4,
+        starting_value: int = 0,
+        dated: bool = False,
+    ):
+        self._base_path_provider = base_path_provider
+        self._max_digits = max_digits
+        self._next_value = starting_value
+        self._dated = dated
+
+    def _get_highest_number_from(self, path: Path) -> int:
+        # Look through directories in path which end in "_{number} and get highest
+        # number"
+        highest_number = 0
+        candidates = [
+            x for x in path.iterdir() if x.is_dir() and re.match(r"^\d+_", x.name)
+        ]
+        if candidates:
+            highest_number = max(
+                int(x.name.split("_", maxsplit=1)[0]) for x in candidates
+            )
+        else:
+            highest_number = self._next_value
+        return highest_number
+
+    def __call__(self, device_name: str | None = None) -> PathInfo:
+        base_path_info = self._base_path_provider.__call__()
+        base_path_dir = Path(base_path_info.directory_path)
+        if self._dated:
+            # Make sure we are the max ID of any other days to keep numbering
+            # consistent.
+            cands = [
+                self._get_highest_number_from(x)
+                for x in base_path_dir.iterdir()
+                if re.match(r"^\d\d\d\d-\d\d-\d\d$", x.name)
+            ]
+            if cands:
+                self._next_value = max(max(cands) + 1, self._next_value)
+
+            path = base_path_dir / date.today().strftime("%Y-%m-%d")
+        else:
+            path = base_path_dir
+
+        val_to_use = self._next_value
+
+        # Get the highest number using files in path, or use
+        # stored next value if no files are found.
+        if path.exists():
+            highest_number = self._get_highest_number_from(path)
+            val_to_use = (
+                highest_number + 1
+                if not highest_number == self._next_value
+                else highest_number
+            )
+
+        self._next_value = val_to_use + 1
+
+        filename = base_path_info.filename
+
+        padded_counter = f"{val_to_use:0{self._max_digits}}"
+        full_path = (
+            path / f"{padded_counter}_{filename.strip('_')}" / filename.rstrip("_")
+        )
+        return PathInfo(
+            directory_path=full_path.parent,
+            directory_uri=None,
+            filename=full_path.name,
+            create_dir_depth=0,
+        )
+
+
 class AutoIncrementingPathProvider(PathProvider):
     """Provides a new numerically incremented path on each call."""
 

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     AsyncStatus,
     FlyerController,
     error_if_none,
+    gather_dict,
     observe_value,
     set_and_wait_for_value,
     wait_for_value,
@@ -202,12 +203,25 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         coord = self.pmac.coord[motor_info.cs_number]
         coros = []
         await coord.defer_moves.set(True)
+
+        motor_readbacks = await gather_dict(
+            {motor: motor.user_readback.get_value() for motor in ramp_up_position}
+        )
+
+        move_times = [
+            abs(position - motor_readbacks[motor])
+            / motor_info.motor_max_velocity[motor]
+            for motor, position in ramp_up_position.items()
+        ]
+
+        longest_time = max(move_times)
+
         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]],
                     position,
-                    set_timeout=10,
+                    set_timeout=longest_time + DEFAULT_TIMEOUT,
                     wait_for_set_completion=False,
                 )
             )

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/fastcs/eiger/_eiger_io.py

@@ -29,7 +29,7 @@ class EigerDetectorIO(Device):
     frame_time: SignalRW[float]
     nimages: SignalRW[int]
     ntrigger: SignalRW[int]
-    nexpi: SignalRW[int]
+    nexpi: SignalRW[int] | None
     trigger_mode: SignalRW[str]
     roi_mode: SignalRW[str]
     photon_energy: SignalRW[float]

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/fastcs/panda/_control.py

@@ -35,7 +35,8 @@ class PandaPcapController(DetectorController):
         await wait_for_value(self.pcap.active, True, timeout=1)
 
     async def wait_for_idle(self):
-        pass
+        if self._arm_status and not self._arm_status.done:
+            await self._arm_status
 
     async def disarm(self):
         await self.pcap.arm.set(False)

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/tango/core/__init__.py

@@ -9,7 +9,9 @@ from ._signal import (
     tango_signal_x,
 )
 from ._tango_transport import (
+    AttributeInfoEx,
     AttributeProxy,
+    CommandInfo,
     CommandProxy,
     CommandProxyReadCharacter,
     TangoDoubleStringTable,
@@ -21,6 +23,7 @@ from ._tango_transport import (
     get_python_type,
     get_source_metadata,
     get_tango_trl,
+    parse_precision,
 )
 from ._utils import (
     DevStateEnum,
@@ -30,7 +33,9 @@ from ._utils import (
 )
 
 __all__ = [
+    "AttributeInfoEx",
     "AttributeProxy",
+    "CommandInfo",
     "CommandProxy",
     "CommandProxyReadCharacter",
     "DevStateEnum",
@@ -44,6 +49,7 @@ __all__ = [
     "infer_python_type",
     "infer_signal_type",
     "make_backend",
+    "parse_precision",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",

{ophyd_async-0.14.0 → ophyd_async-0.14.2}/src/ophyd_async/tango/core/_tango_transport.py

@@ -1,6 +1,7 @@
 import asyncio
 import functools
 import logging
+import re
 import time
 from abc import abstractmethod
 from collections.abc import Callable, Coroutine, Sequence
@@ -582,6 +583,15 @@ class CommandProxy(TangoProxy):
         pass
 
 
+PRECISION_PATTERN = re.compile(r"%\d*\.(\d+)f")
+
+
+def parse_precision(config: AttributeInfoEx):
+    if config.format and (matches := PRECISION_PATTERN.findall(config.format)):
+        return int(matches[0])
+    return None
+
+
 def get_dtype_extended(datatype) -> object | None:
     """For converting tango types to numpy datatype formats."""
     # DevState tango type does not have numpy equivalents
@@ -639,17 +649,8 @@ def get_source_metadata(
             if tr_dtype == CmdArgType.DevState:
                 _choices = list(DevState.names.keys())
 
-            _precision = None
-            if config.format:
-                try:
-                    _precision = int(config.format.split(".")[1].split("f")[0])
-                except (ValueError, IndexError) as exc:
-                    # If parsing config.format fails, _precision remains None.
-                    logger.warning(
-                        "Failed to parse precision from config.format: %s. Error: %s",
-                        config.format,
-                        exc,
-                    )
+            _precision = parse_precision(config)
+
             no_limits = Limits(
                 control=LimitsRange(high=None, low=None),
                 warning=LimitsRange(high=None, low=None),

{ophyd_async-0.14.0 → ophyd_async-0.14.2/src/ophyd_async.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.14.0
+Version: 0.14.2
 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.14.0 → ophyd_async-0.14.2}/src/ophyd_async.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ uv.lock
 .github/workflows/_test.yml
 .github/workflows/_tox.yml
 .github/workflows/ci.yml
+.github/workflows/claude.yml
 .github/workflows/periodic.yml
 docs/conf.py
 docs/explanations.md
@@ -250,11 +251,11 @@ tests/system_tests/epics/signal/test_signals.py
 tests/system_tests/epics/signal/test_yaml_save_ca.yaml
 tests/system_tests/epics/signal/test_yaml_save_pva.yaml
 tests/system_tests/fastcs/panda/test_panda_connect.py
-tests/system_tests/tango/conftest.py
-tests/system_tests/tango/context_subprocess.py
-tests/system_tests/tango/test_base_device.py
-tests/system_tests/tango/test_tango_signals.py
-tests/system_tests/tango/test_tango_transport.py
+tests/system_tests_tango/conftest.py
+tests/system_tests_tango/context_subprocess.py
+tests/system_tests_tango/test_base_device.py
+tests/system_tests_tango/test_tango_signals.py
+tests/system_tests_tango/test_tango_transport.py
 tests/unit_tests/__init__.py
 tests/unit_tests/test_branching.py
 tests/unit_tests/test_cli.py