ophyd-async 0.13.0__tar.gz → 0.13.1__tar.gz

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.copier-answers.yml

@@ -1,6 +1,6 @@
 # Changes here will be overwritten by Copier
-_commit: 2.6.0
-_src_path: gh:DiamondLightSource/python-copier-template
+_commit: 4.1.0
+_src_path: https://github.com/DiamondLightSource/python-copier-template
 author_email: tom.cobb@diamond.ac.uk
 author_name: Tom Cobb
 description: Asynchronous Bluesky hardware abstraction code, compatible with control
@@ -13,4 +13,5 @@ github_org: bluesky
 package_name: ophyd_async
 pypi: true
 repo_name: ophyd-async
+strict_typing: false
 type_checker: pyright

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.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/2.6.0/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/4.1.0/how-to.html).

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,7 +7,7 @@ assignees: ''
 
 ---
 
-Describe the bug, including a clear and concise description of the expected behavior, the actual behavior and the context in which you encountered it (ideally include details of your environment).
+Describe the bug, including a clear and concise description of the expected behaviour, the actual behavior and the context in which you encountered it (ideally include details of your environment).
 
 ## Steps To Reproduce
 Steps to reproduce the behavior:

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/actions/install_requirements/action.yml

@@ -15,7 +15,8 @@ runs:
       run: |
         PYTHON_VERSION="${{ inputs.python-version }}"
         if [ $PYTHON_VERSION == "dev" ]; then
-          PYTHON_VERSION=$(sed -n "s/ARG PYTHON_VERSION=//p" Dockerfile)
+          # python version from Dockerfile, removing potential pinned sha
+          PYTHON_VERSION=$(sed -Ene "s/ARG PYTHON_VERSION=([0-9\.]+).*/\1/p" Dockerfile)
         fi
         echo "PYTHON_VERSION=$PYTHON_VERSION" >> "$GITHUB_ENV"
       shell: bash

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/dependabot.yml

@@ -13,6 +13,8 @@ updates:
       actions:
         patterns:
           - "*"
+    commit-message:
+      prefix: "chore"
 
   - package-ecosystem: "pip"
     directory: "/"
@@ -22,3 +24,5 @@ updates:
       dev-dependencies:
         patterns:
           - "*"
+    commit-message:
+      prefix: "chore"

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/workflows/_docs.yml

@@ -1,6 +1,7 @@
 on:
   workflow_call:
 
+
 jobs:
   build:
     runs-on: ubuntu-latest

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/workflows/_release.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Create GitHub Release
         # We pin to the SHA, not the tag, for security reasons.
         # https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions
-        uses: softprops/action-gh-release@e7a8f85e1c67a31e6ed99a94b41bd0b71bbee6b8 # v2.0.9
+        uses: softprops/action-gh-release@da05d552573ad5aba039eaac05058a918a7bf631 # v2.2.2
         with:
           prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}
           files: "*"

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/workflows/_test.yml

@@ -64,7 +64,7 @@ jobs:
         run: tox -e tests -- --timeout=2
       
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           name: ${{ inputs.python-version }}/${{ inputs.runs-on }}
           files: cov.xml

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.github/workflows/ci.yml

@@ -2,26 +2,24 @@ name: CI
 
 on:
   push:
+    branches:
+      - main
+    tags:
+      - '*'
   pull_request:
 
 jobs:
-  check:
-    uses: ./.github/workflows/_check.yml
 
   lint:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     uses: ./.github/workflows/_tox.yml
     with:
       tox: pre-commit,type-checking
 
   test:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     strategy:
       matrix:
         runs-on: ["ubuntu-latest", "windows-latest"] # can add macos-latest
-        python-version: ["3.10","3.11","3.12"]
+        python-version: ["3.11", "3.12", "3.13"]
         include:
           # Include one that runs in the dev environment
           - runs-on: "ubuntu-latest"
@@ -35,35 +33,28 @@ jobs:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   import_with_no_extras:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     uses: ./.github/workflows/_import_with_no_extras.yml
 
   docs:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     uses: ./.github/workflows/_docs.yml
 
+
   dist:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     uses: ./.github/workflows/_dist.yml
 
   pypi:
+    needs: [dist, test]
     if: github.ref_type == 'tag'
-    needs: dist
     uses: ./.github/workflows/_pypi.yml
     permissions:
       id-token: write
 
   codeql:
-    needs: check
-    if: needs.check.outputs.branch-pr == ''
     uses: ./.github/workflows/_codeql.yml
 
   release:
+    needs: [dist, test, docs]
     if: github.ref_type == 'tag'
-    needs: [dist, docs]
     uses: ./.github/workflows/_release.yml
     permissions:
       contents: write

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       - id: ruff
         name: lint with ruff
         language: system
-        entry: ruff check --force-exclude
+        entry: ruff check --force-exclude --fix
         types: [python]
         require_serial: true
 

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.0
+Version: 0.13.1
 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
@@ -35,10 +35,10 @@ License: BSD 3-Clause License
 Project-URL: GitHub, https://github.com/bluesky/ophyd-async
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -57,7 +57,7 @@ Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango
-Requires-Dist: pytango==10.0.0; extra == "tango"
+Requires-Dist: pytango==10.0.2; extra == "tango"
 Provides-Extra: demo
 Requires-Dist: ipython; extra == "demo"
 Requires-Dist: matplotlib; extra == "demo"

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/docs/explanations/decisions/0008-signal-types.md

@@ -54,8 +54,8 @@ Structure now read from `.value` rather than `.pvi`. Supported in FastCS. Requir
 ## `StrictEnum` is now requried for all strictly checked `Enums`
 ```python
 # old
-from enum import Enum
-class MyEnum(str, Enum):
+from enum import StrEnum
+class MyEnum(StrEnum):
     ONE = "one"
     TWO = "two"
 # new

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/docs/tutorials/installation.md

@@ -2,7 +2,7 @@
 
 ## Check your version of python
 
-You will need python 3.10 or later. You can check your version of python by
+You will need python 3.11 or later. You can check your version of python by
 typing into a terminal:
 
 ```

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/pyproject.toml

@@ -7,9 +7,9 @@ name = "ophyd-async"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: BSD License",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 description = "Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango"
 dependencies = [
@@ -26,13 +26,13 @@ dependencies = [
 dynamic = ["version"]
 license.file = "LICENSE"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 
 [project.optional-dependencies]
 sim = ["h5py"]
 ca = ["aioca>=2.0a4"]
 pva = ["p4p>=4.2.0"]
-tango = ["pytango==10.0.0"]
+tango = ["pytango==10.0.2"]
 demo = ["ipython", "matplotlib", "pyqt6"]
 dev = [
     "ophyd_async[sim]",
@@ -192,3 +192,16 @@ source_modules = [
     "ophyd_async.tango.*",
 ]
 ignore_imports = ["ophyd_async.*.testing.* -> ophyd_async.testing"]
+
+[[tool.importlinter.contracts]]
+name = "ophyd_async.core private modules are not to be used outside ophyd_async.core"
+type = "forbidden"
+forbidden_modules = ["ophyd_async.core.*"]
+source_modules = [
+    "ophyd_async.testing",
+    "ophyd_async.plan_stubs",
+    "ophyd_async.fastcs.*",
+    "ophyd_async.epics.*",
+    "ophyd_async.tango.*",
+]
+allow_indirect_imports = true

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.0'
-__version_tuple__ = version_tuple = (0, 13, 0)
+__version__ = version = '0.13.1'
+__version_tuple__ = version_tuple = (0, 13, 1)
+
+__commit_id__ = commit_id = 'g228f25c8b'

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/core/_detector.py

@@ -84,7 +84,7 @@ class TriggerInfo(ConfinedModel):
     A exposures_per_event > 1 can be useful to have exposures from a faster detector
     able to be zipped with a single exposure from a slower detector. E.g. if
     number_of_events=10 and exposures_per_event=5 then the detector will take
-    10 exposures, but publish 2 StreamDatum indices, and describe() will show a
+    50 exposures, but publish 10 StreamDatum indices, and describe() will show a
     shape of (5, h, w) for each.
     Default is 1.
     """

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/core/_signal.py

@@ -39,8 +39,8 @@ from ._utils import (
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
     try:
         return await asyncio.wait_for(coro, timeout)
-    except asyncio.TimeoutError as e:
-        raise asyncio.TimeoutError(source) from e
+    except TimeoutError as e:
+        raise TimeoutError(source) from e
 
 
 def _add_timeout(func):
@@ -492,7 +492,7 @@ async def observe_signals_value(
         last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
-                raise asyncio.TimeoutError(
+                raise TimeoutError(
                     f"observe_value was still observing signals "
                     f"{[signal.source for signal in signals]} after "
                     f"timeout {done_timeout}s"
@@ -500,8 +500,8 @@ async def observe_signals_value(
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
             try:
                 item = await asyncio.wait_for(q.get(), iteration_timeout)
-            except asyncio.TimeoutError as exc:
-                raise asyncio.TimeoutError(
+            except TimeoutError as exc:
+                raise TimeoutError(
                     f"Timeout Error while waiting {iteration_timeout}s to update "
                     f"{[signal.source for signal in signals]}. "
                     f"Last observed signal and value were {last_item}"
@@ -536,8 +536,8 @@ class _ValueChecker(Generic[SignalDatatypeT]):
     ):
         try:
             await asyncio.wait_for(self._wait_for_value(signal), timeout)
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{signal.name} didn't match {self._matcher_name} in {timeout}s, "
                 f"last value {self._last_value!r}"
             ) from e
@@ -635,8 +635,8 @@ async def set_and_wait_for_other_value(
             await asyncio.wait_for(_wait_for_value(), timeout)
             if wait_for_set_completion:
                 await status
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
                 f" {matcher.__name__}() in {timeout}s"
             ) from e

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/core/_utils.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
-from enum import Enum, EnumMeta
+from enum import Enum, EnumMeta, StrEnum
 from typing import (
     Any,
     Generic,
@@ -59,15 +59,15 @@ class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class StrictEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """All members should exist in the Backend, and there will be no extras."""
 
 
-class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
+class SubsetEnum(StrEnum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
-class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class SupersetEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """Some members should exist in the Backend, and there should be no extras."""
 
 
@@ -243,6 +243,7 @@ def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
+    datatype = get_origin_class(datatype)
     if datatype and issubclass(datatype, Enum):
         if not issubclass(datatype, EnumTypes):
             raise TypeError(

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adandor/_andor.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._andor_controller import Andor2Controller

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adcore/_core_detector.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import SignalR, StandardDetector
-from ophyd_async.core._providers import PathProvider
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
 
 from ._core_io import ADBaseIO, NDPluginBaseIO, NDPluginCBIO
 from ._core_logic import ADBaseContAcqController, ADBaseControllerT

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adcore/_core_io.py

@@ -229,7 +229,7 @@ class NDFileHDFIO(NDFilePluginIO):
     swmr_mode: A[SignalRW[bool], PvSuffix.rbv("SWMRMode")]
     flush_now: A[SignalRW[bool], PvSuffix("FlushNow")]
     xml_file_name: A[SignalRW[str], PvSuffix.rbv("XMLFileName")]
-    num_frames_chunks: A[SignalR[int], PvSuffix("NumFramesChunks_RBV")]
+    num_frames_chunks: A[SignalRW[int], PvSuffix.rbv("NumFramesChunks")]
     chunk_size_auto: A[SignalRW[bool], PvSuffix.rbv("ChunkSizeAuto")]
     lazy_open: A[SignalRW[bool], PvSuffix.rbv("LazyOpen")]
 

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -130,7 +130,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 ):
                     if state in self.good_states:
                         return
-            except asyncio.TimeoutError as exc:
+            except TimeoutError as exc:
                 if state is not None:
                     raise ValueError(
                         f"Final detector state {state.value} not in valid end "
@@ -138,7 +138,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                     ) from exc
                 else:
                     # No updates from the detector, something else is wrong
-                    raise asyncio.TimeoutError(
+                    raise TimeoutError(
                         "Could not monitor detector state: "
                         + self.driver.detector_state.source
                     ) from exc

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adcore/_core_writer.py

@@ -11,15 +11,18 @@ from event_model import (  # type: ignore
 )
 from pydantic import PositiveInt
 
-from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._enums import EnableDisable
-from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
-from ophyd_async.core._signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DatasetDescriber,
+    DetectorWriter,
+    EnableDisable,
+    PathInfo,
+    PathProvider,
+    error_if_none,
     observe_value,
     set_and_wait_for_value,
 )
-from ophyd_async.core._status import AsyncStatus
-from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
 from ophyd_async.epics.core import stop_busy_record
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adcore/_hdf_writer.py

@@ -75,8 +75,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Used by the base class
         self._exposures_per_event = exposures_per_event
 
-        # Determine number of frames that will be saved per HDF chunk
+        # Determine number of frames that will be saved per HDF chunk.
+        # On a fresh IOC startup, this is set to zero until the first capture,
+        # so if it is zero, set it to 1.
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
+        if frames_per_chunk == 0:
+            frames_per_chunk = 1
+            await self.fileio.num_frames_chunks.set(frames_per_chunk)
 
         if not _is_fully_described(detector_shape):
             # Questions:

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -16,10 +16,10 @@ class KinetixTriggerMode(StrictEnum):
 class KinetixReadoutMode(StrictEnum):
     """Readout mode for ADKinetix detector."""
 
-    SENSITIVITY = 1
-    SPEED = 2
-    DYNAMIC_RANGE = 3
-    SUB_ELECTRON = 4
+    SENSITIVITY = "1"
+    SPEED = "2"
+    DYNAMIC_RANGE = "3"
+    SUB_ELECTRON = "4"
 
 
 class KinetixDriverIO(adcore.ADBaseIO):

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,11 +1,7 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
-from ophyd_async.epics.adcore._core_detector import AreaDetector
-from ophyd_async.epics.adcore._core_io import NDPluginBaseIO
-from ophyd_async.epics.adcore._core_writer import ADWriter
-from ophyd_async.epics.adcore._hdf_writer import ADHDFWriter
+from ophyd_async.core import PathProvider, SignalR
+from ophyd_async.epics.adcore import ADHDFWriter, ADWriter, AreaDetector, NDPluginBaseIO
 
 from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/advimba/_vimba_io.py

@@ -30,7 +30,7 @@ class VimbaTriggerSource(StrictEnum):
 class VimbaOverlap(StrictEnum):
     """Overlap modes for the Vimba detector."""
 
-    OFF = OnOff.OFF
+    OFF = OnOff.OFF.value
     PREV_FRAME = "PreviousFrame"
 
 

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/core/_p4p.py

@@ -22,7 +22,6 @@ from ophyd_async.core import (
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
-    StrictEnum,
     Table,
     get_enum_cls,
     get_unique,
@@ -82,7 +81,7 @@ def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMe
     if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
-    if datatype is str or issubclass(datatype, StrictEnum):
+    if datatype is str or get_enum_cls(datatype) is not None:
         if hasattr(display_data, "choices"):
             metadata["choices"] = display_data.choices
         elif hasattr(value_data, "choices"):
@@ -327,7 +326,7 @@ def context() -> Context:
 async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
-    except asyncio.TimeoutError as exc:
+    except TimeoutError as exc:
         logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/core/_pvi_connector.py

@@ -6,13 +6,13 @@ from ophyd_async.core import (
     Device,
     DeviceConnector,
     DeviceFiller,
+    LazyMock,
     Signal,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
 )
-from ophyd_async.core._utils import LazyMock
 
 from ._epics_connector import fill_backend_with_prefix
 from ._signal import PvaSignalBackend, pvget_with_timeout

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/epics/testing/_example_ioc.py

@@ -4,8 +4,7 @@ from typing import Annotated as A
 
 import numpy as np
 
-from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
-from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, SubsetEnum, Table
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import TestingIOC, generate_random_pv_prefix

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/plan_stubs/_settings.py

@@ -13,10 +13,10 @@ from ophyd_async.core import (
     Settings,
     SettingsProvider,
     SignalRW,
+    Table,
     walk_config_signals,
     walk_rw_signals,
 )
-from ophyd_async.core._table import Table
 
 from ._utils import T
 from ._wait_for_awaitable import wait_for_awaitable

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/tango/core/_tango_transport.py

@@ -212,7 +212,7 @@ class AttributeProxy(TangoProxy):
 
                 task = asyncio.create_task(_write())
                 await asyncio.wait_for(task, timeout)
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
@@ -451,7 +451,7 @@ class CommandProxy(TangoProxy):
                     timestamp=time.time(),
                     alarm_severity=0,
                 )
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} command failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(

{ophyd_async-0.13.0 → ophyd_async-0.13.1}/src/ophyd_async/testing/_assert.py

@@ -21,11 +21,11 @@ from ophyd_async.core import (
 from ._utils import T
 
 
-def partial_reading(val: Any) -> dict[str, Any]:
-    """Helper function for building expected reading or configuration dicts.
+def partial_reading(val: Any) -> Mapping[str, Any]:
+    """Helper function for building expected reading or configuration mapping.
 
-    :param val: Value to be wrapped in dict with "value" as the key.
-    :return: The dict that has wrapped the val with key "value".
+    :param val: Value to be wrapped in mapping with "value" as the key.
+    :return: The mapping that has wrapped the val with key "value".
     """
     return {"value": val}
 
@@ -100,7 +100,7 @@ def _assert_readings_approx_equal(
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    expected_configuration: dict[str, dict[str, Any]],
+    expected_configuration: Mapping[str, Mapping[str, Any]],
     full_match: bool = True,
 ) -> None:
     """Assert that a configurable Device has the given configuration.
@@ -108,7 +108,7 @@ async def assert_configuration(
     :param configurable:
         Device with an async ``read_configuration()`` method to get the
         configuration from.
-    :param configuration: The expected configuration from the configurable.
+    :param expected_configuration: The expected configuration from the configurable.
     :param full_match: if expected_reading keys set is same as actual keys set.
         true: exact match
         false: expected_reading keys is subset of actual reading keys