pyobs-qhyccd 2.0.0.dev11__tar.gz → 2.0.0.dev13__tar.gz

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/.github/dependabot.yml

@@ -6,5 +6,10 @@ updates:
       interval: "weekly"
       day: "tuesday"
     target-branch: "develop"
+    groups:
+      patch-and-minor:
+        update-types:
+          - "minor"
+          - "patch"
     labels:
       - "dependencies"

pyobs_qhyccd-2.0.0.dev13/.github/workflows/dependabot-automerge.yml

@@ -0,0 +1,24 @@
+name: Dependabot auto-merge
+
+on: pull_request
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.user.login == 'dependabot[bot]' }}
+    steps:
+      - name: Fetch Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2
+        with:
+          compat-lookup: true
+      - name: Enable auto-merge for patch and minor updates
+        if: ${{ steps.metadata.outputs.update-type == 'version-update:semver-patch' || steps.metadata.outputs.update-type == 'version-update:semver-minor' }}
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/.github/workflows/pypi.yml

@@ -56,7 +56,7 @@ jobs:
       - name: Set up Python
         uses: astral-sh/setup-uv@v5
         with:
-          enable-cache: true
+          enable-cache: false
           python-version: "3.13"
 
       - name: Publish

pyobs_qhyccd-2.0.0.dev13/.github/workflows/pyrefly.yml

@@ -0,0 +1,26 @@
+name: pyrefly
+on: push
+
+jobs:
+  pyrefly:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          python-version: "3.13"
+
+      - name: Install system dependencies
+        run: sudo apt-get install -y libusb-1.0-0-dev libcfitsio-dev
+
+      - name: Install packages
+        run: uv sync --all-extras --dev
+
+      - name: Run pyrefly
+        run: uv run pyrefly check

pyobs_qhyccd-2.0.0.dev13/.github/workflows/pytest.yml

@@ -0,0 +1,28 @@
+name: PyTest
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          python-version: "3.13"
+
+      - name: Install system dependencies
+        run: sudo apt-get install -y libusb-1.0-0-dev libcfitsio-dev
+
+      - name: Install packages
+        run: uv sync --all-extras --dev
+
+      - name: Run tests
+        run: uv run pytest tests
+        env:
+          CI: true

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-qhyccd
-Version: 2.0.0.dev11
+Version: 2.0.0.dev13
 Summary: pyobs module for QHYCCD cameras
 Author-Email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/pyobs_qhyccd/gui.py

@@ -68,12 +68,17 @@ class MainWindow(QtWidgets.QMainWindow):
                 self.device.set_bits_mode(16)
 
         self.expose.start_exposure(self.exposure_time.value)
-        abort_event = asyncio.Event()
+        self.abort_exposure.clear()
         self.device.expose_single_frame()
-        await event_wait(abort_event, self.exposure_time.value - 0.5)
+        aborted = await event_wait(self.abort_exposure, self.exposure_time.value - 0.5)
+        self.expose.set_exposures_left()
+        if aborted:
+            # a cancelled exposure must not be read out (see cancel_exposure's docs)
+            self.device.cancel_exposure()
+            return
+
         loop = asyncio.get_running_loop()
         image_data = await loop.run_in_executor(None, self.device.get_single_frame)
-        self.expose.set_exposures_left()
 
         image = fits.PrimaryHDU(image_data)
         self.data_display_widget.set_data(image)
@@ -81,7 +86,10 @@ class MainWindow(QtWidgets.QMainWindow):
     @qasync.asyncSlot()  # type: ignore
     async def _abort_clicked(self) -> None:
         self.abort_exposure.set()
-        self.abort_exposure = asyncio.Event()
+
+    def closeEvent(self, event) -> None:  # type: ignore[override]
+        self.device.close()
+        super().closeEvent(event)
 
 
 async def async_main(app: QtWidgets.QApplication) -> None:

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/pyobs_qhyccd/qhyccdcamera.py

@@ -10,6 +10,7 @@ from typing import Any, TypeVar, cast
 import numpy as np
 from pyobs.images import Image
 from pyobs.interfaces import (
+    Binning,
     BinningCapabilities,
     BinningState,
     CoolingState,
@@ -27,6 +28,7 @@ from pyobs.interfaces import (
     WindowState,
 )
 from pyobs.modules.camera.basecamera import BaseCamera
+from pyobs.utils.exceptions import AbortedError
 from pyobs.utils.parallel import event_wait
 
 from .qhyccddriver import Control, QHYCCDDriver, set_log_level  # type: ignore
@@ -58,6 +60,7 @@ class QHYCCDCamera(BaseCamera, ICamera, IWindow, IBinning, IAbortable, ICooling,
         BaseCamera.__init__(self, **kwargs)
 
         self._driver: QHYCCDDriver | None = None
+        self._driver_lock = threading.Lock()
         self._setpoint = setpoint
         self._window = (0, 0, 0, 0)
         self._binning = (1, 1)
@@ -70,24 +73,33 @@ class QHYCCDCamera(BaseCamera, ICamera, IWindow, IBinning, IAbortable, ICooling,
 
         self.add_background_task(self._update_cooling)
 
-    @staticmethod
-    async def _run_blocking(func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT) -> bool:
+    async def _run_blocking(self, func: Callable[[], None], timeout: float = _SDK_CALL_TIMEOUT) -> bool:
         """Run a blocking QHYCCD SDK call in a daemon thread, so a hung call can't freeze the module.
 
         A plain executor isn't used here, since its worker threads are non-daemon and Python joins
         them on interpreter shutdown -- a hung call would then just move the freeze to process exit.
 
+        Every SDK call is serialized behind self._driver_lock, so the helper threads and the 1s
+        cooling poll never touch the driver handle concurrently. On timeout the worker is left
+        running in the background; its result callback is guarded so it can't set_result on an
+        already-cancelled future.
+
         Returns:
             True if func completed within timeout, False if it's still running in the background.
         """
         loop = asyncio.get_running_loop()
         future: asyncio.Future[None] = loop.create_future()
 
+        def _set_result() -> None:
+            if not future.done():
+                future.set_result(None)
+
         def _wrapper() -> None:
             try:
-                func()
+                with self._driver_lock:
+                    func()
             finally:
-                loop.call_soon_threadsafe(future.set_result, None)
+                loop.call_soon_threadsafe(_set_result)
 
         threading.Thread(target=_wrapper, daemon=True).start()
         try:
@@ -198,21 +210,21 @@ class QHYCCDCamera(BaseCamera, ICamera, IWindow, IBinning, IAbortable, ICooling,
 
             await self._run_blocking_or_raise(_set_custom_params)
 
-    async def _available_binnings(self) -> list[BinningState]:
+    async def _available_binnings(self) -> list[Binning]:
         if self._driver is None:
             return []
         driver = self._driver
 
-        def _get() -> list[BinningState]:
+        def _get() -> list[Binning]:
             binnings = []
             if driver.is_control_available(Control.CAM_BIN1X1MODE):
-                binnings.append(BinningState(x=1, y=1))
+                binnings.append(Binning(x=1, y=1))
             if driver.is_control_available(Control.CAM_BIN2X2MODE):
-                binnings.append(BinningState(x=2, y=2))
+                binnings.append(Binning(x=2, y=2))
             if driver.is_control_available(Control.CAM_BIN3X3MODE):
-                binnings.append(BinningState(x=3, y=3))
+                binnings.append(Binning(x=3, y=3))
             if driver.is_control_available(Control.CAM_BIN4X4MODE):
-                binnings.append(BinningState(x=4, y=4))
+                binnings.append(Binning(x=4, y=4))
             return binnings
 
         return await self._run_blocking_or_raise(_get)
@@ -320,20 +332,28 @@ class QHYCCDCamera(BaseCamera, ICamera, IWindow, IBinning, IAbortable, ICooling,
         )
         date_obs = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f")
         await self._run_blocking_or_raise(driver.expose_single_frame)
-        await self._wait_exposure(abort_event, exposure_time, open_shutter)
-        loop = asyncio.get_running_loop()
-        image_data = await loop.run_in_executor(None, driver.get_single_frame)
+        aborted = await self._wait_exposure(abort_event, exposure_time, open_shutter)
+        if aborted:
+            # a cancelled exposure must not be read out (see cancel_exposure/_abort_exposure)
+            raise AbortedError()
+        image_data = await self._run_blocking_or_raise(driver.get_single_frame)
         return await self._get_image_with_header(image_data, date_obs, exposure_time)
 
-    async def _wait_exposure(self, abort_event: asyncio.Event, exposure_time: float, open_shutter: bool) -> None:
-        """Wait for exposure to finish."""
-        await event_wait(abort_event, exposure_time - 0.5)
+    async def _wait_exposure(self, abort_event: asyncio.Event, exposure_time: float, open_shutter: bool) -> bool:
+        """Wait for exposure to finish.
+
+        Returns:
+            True if the exposure was aborted, False if it ran to completion.
+        """
+        return await event_wait(abort_event, exposure_time - 0.5)
 
     async def _abort_exposure(self) -> None:
         """Abort the running exposure."""
         if self._driver is None:
             raise ValueError("No camera driver.")
-        # self._driver.cancel_exposure()
+        driver = self._driver
+        if not await self._run_blocking(driver.cancel_exposure):
+            log.error("Timed out cancelling QHYCCD exposure after %.1fs.", _SDK_CALL_TIMEOUT)
 
     async def _get_cooling_power(self) -> float:
         if self._driver is None:

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/pyobs_qhyccd/qhyccddriver.pyx

@@ -79,7 +79,7 @@ class Control(Enum):
     CAM_IS_COLOR = CONTROL_ID.CAM_IS_COLOR,
     hasHardwareFrameCounter = CONTROL_ID.hasHardwareFrameCounter,
     CONTROL_MAX_ID = CONTROL_ID.CONTROL_MAX_ID,
-    CAM_HUMIDITY = CONTROL_ID.CAM_HUMIDITY
+    CAM_HUMIDITY = CONTROL_ID.CAM_HUMIDITY,
 
 
 def set_log_level(log_level):
@@ -216,6 +216,15 @@ cdef class QHYCCDDriver:
     def expose_single_frame(self):
         return ExpQHYCCDSingleFrame(self._device)
 
+    def cancel_exposure(self):
+        """Force-stop a running exposure without reading out its (incomplete) data.
+
+        Raises:
+            ValueError: If cancelling failed.
+        """
+        if CancelQHYCCDExposingAndReadout(self._device) != 0:
+            raise ValueError('Could not cancel exposure.')
+
     def get_mem_length(self):
         return GetQHYCCDMemLength(self._device)
 

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-qhyccd"
-version = "2.0.0.dev11"
+version = "2.0.0.dev13"
 description = "pyobs module for QHYCCD cameras"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"
@@ -24,6 +24,8 @@ dev = [
     "pyrefly>=1.1.1",
     "pre-commit>=4.2.0,<5",
     "cython>=3.0.0,<4",
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
 ]
 
 [tool.setuptools]
@@ -61,3 +63,7 @@ select = ["E", "F", "W", "I", "UP", "G"]
 
 [tool.pyrefly]
 python-version = "3.11"
+project-excludes = ["pyobs_qhyccd/gui.py"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"

pyobs_qhyccd-2.0.0.dev13/tests/test_import.py

@@ -0,0 +1,23 @@
+"""Smoke tests: import the driver and instantiate it without hardware, asserting the
+interfaces it claims.
+
+The Cython extension (qhyccddriver) links the vendored QHYCCD static library during
+install, but device enumeration/opening only happens inside open(), so instantiation
+is safe with no QHYCCD hardware attached.
+"""
+
+from pyobs.interfaces import IAbortable, IBinning, ICamera, ICooling, IGain, IWindow
+from pyobs.modules import Module
+
+from pyobs_qhyccd import QHYCCDCamera
+
+
+def test_instantiate_camera() -> None:
+    camera = QHYCCDCamera()
+    assert isinstance(camera, Module)
+    assert isinstance(camera, ICamera)
+    assert isinstance(camera, IWindow)
+    assert isinstance(camera, IBinning)
+    assert isinstance(camera, ICooling)
+    assert isinstance(camera, IGain)
+    assert isinstance(camera, IAbortable)

pyobs_qhyccd-2.0.0.dev13/tests/test_qhyccdcamera.py

@@ -0,0 +1,157 @@
+"""Unit tests for the non-hardware logic in QHYCCDCamera: constructor defaults, the
+window/binning setters, the cooling-control guard, and the _run_blocking wrappers.
+
+Hardware I/O (opening, exposing, reading out) is out of scope here.
+"""
+
+import asyncio
+import threading
+import time
+from unittest.mock import AsyncMock
+
+import pytest
+from pyobs.interfaces import IBinning, ICooling, IWindow
+
+from pyobs_qhyccd import QHYCCDCamera
+
+
+def test_constructor_defaults() -> None:
+    camera = QHYCCDCamera()
+    assert camera._setpoint == -10
+    assert camera._window == (0, 0, 0, 0)
+    assert camera._binning == (1, 1)
+    assert camera._effective_area == (0, 0, 0, 0)
+    assert camera._cooling_step == 1.0
+    assert camera._cooling_wait == 60.0
+    assert camera._driver is None
+
+
+@pytest.mark.asyncio
+async def test_set_window() -> None:
+    camera = QHYCCDCamera()
+    camera.comm.set_state = AsyncMock()  # type: ignore[method-assign]
+
+    await camera.set_window(10, 20, 100, 200)
+
+    assert camera._window == (10, 20, 100, 200)
+    assert camera.comm.set_state.await_args is not None
+    interface, state = camera.comm.set_state.await_args.args
+    assert interface is IWindow
+    assert (state.x, state.y, state.width, state.height) == (10, 20, 100, 200)
+
+
+@pytest.mark.asyncio
+async def test_set_binning() -> None:
+    camera = QHYCCDCamera()
+    camera.comm.set_state = AsyncMock()  # type: ignore[method-assign]
+
+    await camera.set_binning(2, 3)
+
+    assert camera._binning == (2, 3)
+    assert camera.comm.set_state.await_args is not None
+    interface, state = camera.comm.set_state.await_args.args
+    assert interface is IBinning
+    assert (state.x, state.y) == (2, 3)
+
+
+@pytest.mark.asyncio
+async def test_set_cooling_without_driver_publishes_state() -> None:
+    camera = QHYCCDCamera()
+    camera.comm.set_state = AsyncMock()  # type: ignore[method-assign]
+
+    await camera.set_cooling(True, -15.0)
+
+    # no driver attached, so power can't be read back and is published as None
+    assert camera._setpoint == -15.0
+    assert camera.comm.set_state.await_args is not None
+    interface, state = camera.comm.set_state.await_args.args
+    assert interface is ICooling
+    assert (state.setpoint, state.power, state.enabled) == (-15.0, None, True)
+
+
+@pytest.mark.asyncio
+async def test_set_cooling_disabled_publishes_no_setpoint() -> None:
+    camera = QHYCCDCamera()
+    camera.comm.set_state = AsyncMock()  # type: ignore[method-assign]
+
+    await camera.set_cooling(False, -15.0)
+
+    # disabling cooling publishes setpoint=None even though a setpoint was passed in
+    assert camera.comm.set_state.await_args is not None
+    interface, state = camera.comm.set_state.await_args.args
+    assert interface is ICooling
+    assert (state.setpoint, state.enabled) == (None, False)
+
+
+@pytest.mark.asyncio
+async def test_set_gain_requires_driver() -> None:
+    camera = QHYCCDCamera()
+    with pytest.raises(ValueError):
+        await camera.set_gain(10.0)
+
+
+@pytest.mark.asyncio
+async def test_run_blocking_runs_func_and_returns_true() -> None:
+    ran: list[bool] = []
+
+    def fast() -> None:
+        ran.append(True)
+
+    camera = QHYCCDCamera()
+    assert await camera._run_blocking(fast) is True
+    assert ran == [True]
+
+
+@pytest.mark.asyncio
+async def test_run_blocking_times_out() -> None:
+    done = threading.Event()
+
+    def slow() -> None:
+        done.wait()
+
+    camera = QHYCCDCamera()
+    assert await camera._run_blocking(slow, timeout=0.01) is False
+    done.set()
+    await asyncio.sleep(0.05)
+
+
+@pytest.mark.asyncio
+async def test_run_blocking_serializes_concurrent_calls() -> None:
+    camera = QHYCCDCamera()
+    active = 0
+    max_active = 0
+    track_lock = threading.Lock()
+
+    def worker() -> None:
+        nonlocal active, max_active
+        with track_lock:
+            active += 1
+            max_active = max(max_active, active)
+        time.sleep(0.05)
+        with track_lock:
+            active -= 1
+
+    await asyncio.gather(
+        camera._run_blocking(worker),
+        camera._run_blocking(worker),
+        camera._run_blocking(worker),
+    )
+
+    assert max_active == 1
+
+
+@pytest.mark.asyncio
+async def test_run_blocking_or_raise_returns_value() -> None:
+    camera = QHYCCDCamera()
+    assert await camera._run_blocking_or_raise(lambda: 42) == 42
+
+
+@pytest.mark.asyncio
+async def test_run_blocking_or_raise_reraises() -> None:
+    camera = QHYCCDCamera()
+
+    def boom() -> int:
+        raise ValueError("boom")
+
+    with pytest.raises(ValueError):
+        await camera._run_blocking_or_raise(boom)

{pyobs_qhyccd-2.0.0.dev11 → pyobs_qhyccd-2.0.0.dev13}/uv.lock

@@ -1007,6 +1007,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7f/ec/6b120b4a86f6fadc7ddb1d7c7cdcb15bcfb332deb022ab60df51bcd4494c/influxdb_client-1.50.0-py3-none-any.whl", hash = "sha256:f172975cf7f0c95bfe74f288b31273393b164d2c58a948de55497d9956ab49be", size = 746289, upload-time = "2026-01-23T09:39:37.377Z" },
 ]
 
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
 [[package]]
 name = "invoke"
 version = "3.0.3"
@@ -1772,6 +1781,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
 ]
 
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
 [[package]]
 name = "pre-commit"
 version = "4.6.1"
@@ -2160,6 +2178,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b4/11/97233cf23ad5411ac6f13b1d6ee3888f90ace4f974d9bf9db887aa428912/pyerfa-2.0.1.5-cp39-abi3-win_amd64.whl", hash = "sha256:66292d437dcf75925b694977aa06eb697126e7b86553e620371ed3e48b5e0ad0", size = 349410, upload-time = "2024-11-11T15:22:24.817Z" },
 ]
 
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
 [[package]]
 name = "pynacl"
 version = "1.6.2"
@@ -2241,7 +2268,7 @@ gui = [
 
 [[package]]
 name = "pyobs-qhyccd"
-version = "2.0.0.dev11"
+version = "2.0.0.dev13"
 source = { editable = "." }
 dependencies = [
     { name = "astropy" },
@@ -2261,6 +2288,8 @@ dev = [
     { name = "cython" },
     { name = "pre-commit" },
     { name = "pyrefly" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
     { name = "ruff" },
 ]
 
@@ -2280,6 +2309,8 @@ dev = [
     { name = "cython", specifier = ">=3.0.0,<4" },
     { name = "pre-commit", specifier = ">=4.2.0,<5" },
     { name = "pyrefly", specifier = ">=1.1.1" },
+    { name = "pytest", specifier = ">=8.0.0" },
+    { name = "pytest-asyncio", specifier = ">=0.24.0" },
     { name = "ruff", specifier = ">=0.9.0" },
 ]
 
@@ -2359,6 +2390,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/53/27/d17f25e45820e633a70e6109b35991eda09a5e8000c2a306f0ab7538d48c/pyside6_essentials-6.11.0-cp310-abi3-win_arm64.whl", hash = "sha256:81ca603dbf21bc39f89bb42db215c25ebe0c879a1a4c387625c321d2730ec187", size = 56337457, upload-time = "2026-03-23T12:43:43.573Z" },
 ]
 
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"