pyobs-qhyccd 2.0.0.dev9__tar.gz → 2.0.0.dev12__tar.gz

pyobs_qhyccd-2.0.0.dev12/.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "tuesday"
+    target-branch: "develop"
+    groups:
+      patch-and-minor:
+        update-types:
+          - "minor"
+          - "patch"
+    labels:
+      - "dependencies"

pyobs_qhyccd-2.0.0.dev12/.github/workflows/pypi.yml

@@ -0,0 +1,65 @@
+name: Publish package to PyPI
+on:
+  push:
+    tags:
+    - 'v*'
+jobs:
+  build-wheels:
+    name: Build wheels
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v4.2.0
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: wheelhouse/*.whl
+
+  build-sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+    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: Build sdist
+        run: uv build --sdist
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: Publish to PyPI
+    needs: [build-wheels, build-sdist]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: false
+          python-version: "3.13"
+
+      - name: Publish
+        env:
+          PYPI_TOKEN: ${{ secrets.pypi_password }}
+        run: uv publish --token $PYPI_TOKEN dist/*

pyobs_qhyccd-2.0.0.dev12/.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.dev9/.github/workflows/pypi.yml → pyobs_qhyccd-2.0.0.dev12/.github/workflows/pytest.yml

@@ -1,12 +1,11 @@
-name: Publish package to PyPI
-on:
-  push:
-    tags:
-    - 'v*'
+name: PyTest
+on: push
+
 jobs:
-  build-n-publish:
-    name: Build and publish package to PyPI
+  test:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
+
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4
@@ -20,10 +19,10 @@ jobs:
       - name: Install system dependencies
         run: sudo apt-get install -y libusb-1.0-0-dev libcfitsio-dev
 
-      - name: Build
-        run: uv build --sdist
+      - name: Install packages
+        run: uv sync --all-extras --dev
 
-      - name: Publish
+      - name: Run tests
+        run: uv run pytest tests
         env:
-          PYPI_TOKEN: ${{ secrets.pypi_password }}
-        run: uv publish --token $PYPI_TOKEN
+          CI: true

{pyobs_qhyccd-2.0.0.dev9 → pyobs_qhyccd-2.0.0.dev12}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: pyobs-qhyccd
-Version: 2.0.0.dev9
+Version: 2.0.0.dev12
 Summary: pyobs module for QHYCCD cameras
 Author-Email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
-Requires-Python: <3.14,>=3.11
+Requires-Python: >=3.11
 Requires-Dist: astropy<8,>=7.0.1
 Requires-Dist: numpy<3,>=2.2.5
-Requires-Dist: pyobs-core<3,>=2.0.0.dev6
+Requires-Dist: pyobs-core<3,>=2.0.0.dev48
 Provides-Extra: gui
-Requires-Dist: pyobs-core[gui]<3,>=2.0.0.dev6; extra == "gui"
+Requires-Dist: pyobs-core[gui]<3,>=2.0.0.dev48; extra == "gui"
 Requires-Dist: qasync>=0.28.0; extra == "gui"
 

{pyobs_qhyccd-2.0.0.dev9 → pyobs_qhyccd-2.0.0.dev12}/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,
@@ -198,21 +199,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)

{pyobs_qhyccd-2.0.0.dev9 → pyobs_qhyccd-2.0.0.dev12}/pyproject.toml

@@ -1,29 +1,31 @@
 [project]
 name = "pyobs-qhyccd"
-version = "2.0.0.dev9"
+version = "2.0.0.dev12"
 description = "pyobs module for QHYCCD cameras"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
-requires-python = ">=3.11,<3.14"
+requires-python = ">=3.11"
 license = "MIT"
 dependencies = [
     "astropy>=7.0.1,<8",
     "numpy>=2.2.5,<3",
-    "pyobs-core>=2.0.0.dev6,<3",
+    "pyobs-core>=2.0.0.dev48,<3",
 ]
 
 [project.optional-dependencies]
 gui = [
-    "pyobs-core[gui]>=2.0.0.dev6,<3",
+    "pyobs-core[gui]>=2.0.0.dev48,<3",
     "qasync>=0.28.0",
 ]
 
 [dependency-groups]
 dev = [
-    "black>=25.1.0,<26",
+    "black>=25.1.0,<27",
     "ruff>=0.9.0",
     "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]
@@ -35,6 +37,15 @@ qhyccd-gui = 'pyobs_qhyccd.gui:main'
 [tool.scikit-build]
 wheel.packages = ["pyobs_qhyccd"]
 
+[tool.cibuildwheel]
+build = "cp311-* cp312-* cp313-* cp314-*"
+skip = "*-musllinux_* *-manylinux_i686"
+archs = ["x86_64"]
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+before-all = "dnf install -y epel-release && dnf install -y cfitsio-devel libusbx-devel"
+
 [build-system]
 requires = ["scikit_build_core>=0.12", "cython>=3.0", "cython-cmake", "numpy>=2.0"]
 build-backend = "scikit_build_core.build"
@@ -52,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.dev12/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.dev12/tests/test_qhyccdcamera.py

@@ -0,0 +1,129 @@
+"""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
+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)
+
+    assert await QHYCCDCamera._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()
+
+    assert await QHYCCDCamera._run_blocking(slow, timeout=0.01) is False
+    done.set()
+    await asyncio.sleep(0.05)
+
+
+@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)