pyobs-alpaca 2.0.0.dev3__tar.gz → 2.0.0.dev5__tar.gz

pyobs_alpaca-2.0.0.dev5/.flake8

@@ -0,0 +1,14 @@
+[flake8]
+ignore =
+    E203, E266, E501, W503, F403,
+    # E704: Multiple statements on one line (def)
+    E704,
+    # E722: do not use bare 'except'
+    E722
+    # E701: multiple statements on one line (colon)
+    E701
+per-file-ignores = __init__.py:F401
+max-line-length = 120
+max-complexity = 30
+select = B, C, E, F, W, T4, B9
+exclude = .git,.venv,__pycache__,docs,build,dist

pyobs_alpaca-2.0.0.dev5/.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_alpaca-2.0.0.dev5/.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_alpaca-2.0.0.dev5/.github/workflows/pyrefly.yml

@@ -0,0 +1,23 @@
+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 packages
+        run: uv sync --all-extras --dev
+
+      - name: Run pyrefly
+        run: uv run pyrefly check

pyobs_alpaca-2.0.0.dev5/.github/workflows/pytest.yml

@@ -0,0 +1,25 @@
+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 packages
+        run: uv sync --all-extras --dev
+
+      - name: Run tests
+        run: uv run pytest tests
+        env:
+          CI: true

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: pyobs-alpaca
-Version: 2.0.0.dev3
+Version: 2.0.0.dev5
 Summary: pyobs module for ASCOM Alpaca
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: numpy<3,>=2.2.5
-Requires-Dist: pyobs-core<3,>=2.0.0.dev1
+Requires-Dist: pyobs-core<3,>=2.0.0.dev82

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/pyobs_alpaca/device.py

@@ -23,6 +23,19 @@ class ServerGetResponse(NamedTuple):
     Value: Any
 
 
+DEVICE_INIT_KWARGS = {"server", "port", "device_type", "device", "version", "alive_parameter"}
+"""Names of AlpacaDevice's own constructor params -- callers that also thread **kwargs through
+their own cooperative super().__init__() chain must exclude these first, since nothing in that
+chain (Module/mixins) recognizes them and they'd otherwise leak through to object.__init__()."""
+
+OBJECT_SHARED_KWARGS = {"vfs", "comm", "timezone", "location", "observer"}
+"""Names of pyobs.object.Object's own constructor params. AlpacaDevice forwards anything beyond
+its own params (see DEVICE_INIT_KWARGS) straight to Object cooperatively, so callers building an
+AlpacaDevice from a module's **kwargs must restrict to DEVICE_INIT_KWARGS | OBJECT_SHARED_KWARGS --
+any module/mixin-specific kwarg (e.g. fits_namespaces, motion_status_interfaces) would otherwise
+leak through to object.__init__() the same way."""
+
+
 class AlpacaDevice(Object):
     def __init__(
         self,

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/pyobs_alpaca/dome.py

@@ -13,12 +13,12 @@ from pyobs.utils.enums import MotionStatus
 from pyobs.utils.parallel import event_wait
 from pyobs.utils.threads import LockWithAbort
 
-from .device import AlpacaDevice
+from .device import DEVICE_INIT_KWARGS, OBJECT_SHARED_KWARGS, AlpacaDevice
 
 log = logging.getLogger("pyobs")
 
 
-class AlpacaDome(FollowMixin, BaseDome):
+class AlpacaDome(BaseDome, FollowMixin):
     __module__ = "pyobs_alpaca"
 
     def __init__(self, tolerance: float = 3, park_az: float = 180, follow: str | None = None, **kwargs: Any):
@@ -29,10 +29,20 @@ class AlpacaDome(FollowMixin, BaseDome):
             park_az: Azimuth for park position.
             follow: Name of other device (e.g. telescope) to follow.
         """
-        BaseDome.__init__(self, **kwargs, motion_status_interfaces=["IDome"])
+        super().__init__(
+            motion_status_interfaces=["IDome"],
+            device=follow,
+            interval=10,
+            tolerance=tolerance,
+            mode=IPointingAltAz,
+            only_follow_when_ready=False,
+            **{k: v for k, v in kwargs.items() if k not in DEVICE_INIT_KWARGS},
+        )
 
         # device
-        self._device = self.add_child_object(AlpacaDevice, **kwargs)
+        self._device = self.add_child_object(
+            AlpacaDevice, **{k: v for k, v in kwargs.items() if k in DEVICE_INIT_KWARGS | OBJECT_SHARED_KWARGS}
+        )
 
         # store
         self._tolerance = tolerance
@@ -53,11 +63,6 @@ class AlpacaDome(FollowMixin, BaseDome):
         # start thread
         self.add_background_task(self._update_status)
 
-        # mixins
-        FollowMixin.__init__(
-            self, device=follow, interval=10, tolerance=tolerance, mode=IPointingAltAz, only_follow_when_ready=False
-        )
-
     async def open(self) -> None:
         """Open module."""
         await BaseDome.open(self)

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/pyobs_alpaca/focuser.py

@@ -2,26 +2,31 @@ import asyncio
 import logging
 from typing import Any
 
-from pyobs.interfaces import FocuserState, IFitsHeaderBefore, IFocuser, IReady, ReadyState
+from pyobs.interfaces import FitsHeaderEntry, FocuserState, IFitsHeaderBefore, IFocuser, IReady, ReadyState
 from pyobs.mixins import MotionStatusMixin
 from pyobs.modules import Module, timeout
 from pyobs.utils import exceptions as exc
 from pyobs.utils.enums import MotionStatus
 from pyobs.utils.threads import LockWithAbort
 
-from .device import AlpacaDevice
+from .device import DEVICE_INIT_KWARGS, OBJECT_SHARED_KWARGS, AlpacaDevice
 
 log = logging.getLogger(__name__)
 
 
-class AlpacaFocuser(MotionStatusMixin, IFocuser, IFitsHeaderBefore, Module):
+class AlpacaFocuser(Module, MotionStatusMixin, IFocuser, IFitsHeaderBefore):
     __module__ = "pyobs_alpaca"
 
     def __init__(self, **kwargs: Any):
-        Module.__init__(self, **kwargs)
+        super().__init__(
+            motion_status_interfaces=["IFocuser"],
+            **{k: v for k, v in kwargs.items() if k not in DEVICE_INIT_KWARGS},
+        )
 
         # device
-        self._device = self.add_child_object(AlpacaDevice, **kwargs)
+        self._device = self.add_child_object(
+            AlpacaDevice, **{k: v for k, v in kwargs.items() if k in DEVICE_INIT_KWARGS | OBJECT_SHARED_KWARGS}
+        )
 
         # variables
         self._focus_offset = 0.0
@@ -30,11 +35,8 @@ class AlpacaFocuser(MotionStatusMixin, IFocuser, IFitsHeaderBefore, Module):
         self._lock_motion = asyncio.Lock()
         self._abort_motion = asyncio.Event()
 
-        # init mixins
-        MotionStatusMixin.__init__(self, motion_status_interfaces=["IFocuser"])
-
         # register exception
-        exc.register_exception(exc.MotionError, 3, timespan=600, callback=self._default_remote_error_callback)
+        self._register_exception(exc.MotionError, 3, timespan=600, callback=self._default_remote_error_callback)
 
     async def open(self) -> None:
         """Open module."""
@@ -57,13 +59,13 @@ class AlpacaFocuser(MotionStatusMixin, IFocuser, IFitsHeaderBefore, Module):
 
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
-    ) -> dict[str, tuple[Any, str]]:
+    ) -> dict[str, FitsHeaderEntry]:
         """Returns FITS header for the current status of this module."""
 
         try:
             pos = await self._device.get("Position")
             step = await self._device.get("StepSize") * 1000.0
-            return {"TEL-FOCU": (pos / step, "Focus of telescope [mm]")}
+            return {"TEL-FOCU": FitsHeaderEntry(pos / step, "Focus of telescope [mm]")}
         except ConnectionError as e:
             log.warning("Could not determine focus position: %s", e)
             return {}

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/pyobs_alpaca/telescope.py

@@ -6,6 +6,7 @@ import numpy as np
 from pyobs.events import OffsetsRaDecEvent
 from pyobs.interfaces import (
     AltAzState,
+    FitsHeaderEntry,
     IFitsHeaderBefore,
     IOffsetsRaDec,
     IPointingAltAz,
@@ -24,7 +25,7 @@ from pyobs.utils.enums import MotionStatus
 from pyobs.utils.parallel import acquire_lock, event_wait
 from pyobs.utils.threads import LockWithAbort
 
-from .device import AlpacaDevice
+from .device import DEVICE_INIT_KWARGS, OBJECT_SHARED_KWARGS, AlpacaDevice
 
 log = logging.getLogger("pyobs")
 
@@ -39,10 +40,15 @@ class AlpacaTelescope(BaseTelescope, FitsNamespaceMixin, IFitsHeaderBefore, IOff
             settle_time: Time in seconds to wait after slew before finishing.
             park_position: Alt/Az park position.
         """
-        BaseTelescope.__init__(self, **kwargs, motion_status_interfaces=["ITelescope"])
+        super().__init__(
+            motion_status_interfaces=["ITelescope"],
+            **{k: v for k, v in kwargs.items() if k not in DEVICE_INIT_KWARGS},
+        )
 
         # device
-        self._device = self.add_child_object(AlpacaDevice, **kwargs)
+        self._device = self.add_child_object(
+            AlpacaDevice, **{k: v for k, v in kwargs.items() if k in DEVICE_INIT_KWARGS | OBJECT_SHARED_KWARGS}
+        )
 
         # variables
         self._settle_time = settle_time
@@ -56,9 +62,6 @@ class AlpacaTelescope(BaseTelescope, FitsNamespaceMixin, IFitsHeaderBefore, IOff
         self._cached_ra: float | None = None
         self._cached_dec: float | None = None
 
-        # mixins
-        FitsNamespaceMixin.__init__(self, **kwargs)
-
         # background position polling
         self.add_background_task(self._update_position)
 
@@ -219,6 +222,10 @@ class AlpacaTelescope(BaseTelescope, FitsNamespaceMixin, IFitsHeaderBefore, IOff
             await self.stop_motion()
             raise exc.MoveError("Could not move telescope to RA/Dec.")
 
+    async def _set_tracking_rate(self, ra_rate: float, dec_rate: float) -> None:
+        """Tracking rates are not supported by the Alpaca telescope driver."""
+        raise NotImplementedError
+
     @timeout(10000)
     async def set_offsets_radec(self, dra: float, ddec: float, **kwargs: Any) -> None:
         """Move an RA/Dec offset."""
@@ -295,14 +302,14 @@ class AlpacaTelescope(BaseTelescope, FitsNamespaceMixin, IFitsHeaderBefore, IOff
 
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
-    ) -> dict[str, tuple[Any, str]]:
+    ) -> dict[str, FitsHeaderEntry]:
         """Returns FITS header for the current status of this module."""
 
         hdr = await BaseTelescope.get_fits_header_before(self)
 
         try:
-            hdr["RAOFF"] = (self._offset_ra, "RA offset [deg]")
-            hdr["DECOFF"] = (self._offset_dec, "Dec offset [deg]")
+            hdr["RAOFF"] = FitsHeaderEntry(self._offset_ra, "RA offset [deg]")
+            hdr["DECOFF"] = FitsHeaderEntry(self._offset_dec, "Dec offset [deg]")
             return self._filter_fits_namespace(hdr, namespaces=namespaces, **kwargs)
         except ConnectionError:
             return {}

{pyobs_alpaca-2.0.0.dev3 → pyobs_alpaca-2.0.0.dev5}/pyproject.toml

@@ -1,21 +1,23 @@
 [project]
 name = "pyobs-alpaca"
-version = "2.0.0.dev3"
+version = "2.0.0.dev5"
 description = "pyobs module for ASCOM Alpaca"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"
 license = "MIT"
 dependencies = [
     "numpy>=2.2.5,<3",
-    "pyobs-core>=2.0.0.dev1,<3",
+    "pyobs-core>=2.0.0.dev82,<3",
 ]
 
 [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",
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
 ]
 
 [build-system]
@@ -35,3 +37,6 @@ select = ["E", "F", "W", "I", "UP", "G"]
 
 [tool.pyrefly]
 python-version = "3.11"
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"

pyobs_alpaca-2.0.0.dev5/tests/test_cooperative_init.py

@@ -0,0 +1,64 @@
+"""Regression tests for the cooperative-super()-chain conversion of AlpacaDome, AlpacaFocuser,
+and AlpacaTelescope.
+
+Each of these classes used to make separate, explicit calls to its Module/Base and mixin
+__init__ methods with unfiltered kwargs, instead of a single cooperative super().__init__()
+call. Against pyobs-core's cooperative __init__ chains, that pattern either drops kwargs a
+sibling mixin declares (leaking them to object.__init__()) or re-threads already-consumed
+kwargs through a second, redundant call -- both raise TypeError. If that happens here, these
+constructor calls themselves raise instead of returning.
+"""
+
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+from pyobs.mixins.follow import FollowMixin
+from pyobs.object import Object
+from pyobs.utils.enums import MotionStatus
+
+from pyobs_alpaca import AlpacaDome, AlpacaFocuser, AlpacaTelescope
+from pyobs_alpaca.device import DEVICE_INIT_KWARGS, OBJECT_SHARED_KWARGS, AlpacaDevice
+
+_DEVICE_ARGS = dict(server="localhost", port=11111, device_type="dome", device=0)
+
+
+def _param_names(func: Callable[..., Any]) -> set[str]:
+    return {name for name in inspect.signature(func).parameters if name not in ("self", "kwargs")}
+
+
+def test_device_init_kwargs_matches_alpaca_device_signature() -> None:
+    """Keeps DEVICE_INIT_KWARGS honest: if AlpacaDevice's constructor ever gains/loses a param
+    without updating this set, callers threading a module's **kwargs through both AlpacaDevice
+    and the module's own super().__init__() chain would silently start leaking kwargs to
+    object.__init__() again -- exactly the bug this whole conversion fixes."""
+    assert DEVICE_INIT_KWARGS == _param_names(AlpacaDevice.__init__)
+
+
+def test_object_shared_kwargs_matches_object_signature() -> None:
+    """Same invariant as above, for the Object-level kwargs AlpacaDevice forwards cooperatively
+    (and that the module chain also needs, e.g. comm/vfs)."""
+    assert OBJECT_SHARED_KWARGS == _param_names(Object.__init__)
+
+
+def test_dome_constructor_threads_kwargs_cooperatively() -> None:
+    dome = AlpacaDome(tolerance=5, follow="telescope", **_DEVICE_ARGS)
+    assert dome.motion_status() == MotionStatus.UNKNOWN
+    assert isinstance(dome, FollowMixin)
+    assert dome.is_following is True
+    assert dome._tolerance == 5
+
+
+def test_focuser_constructor_threads_kwargs_cooperatively() -> None:
+    focuser = AlpacaFocuser(**{**_DEVICE_ARGS, "device_type": "focuser"})
+    assert focuser.motion_status() == MotionStatus.UNKNOWN
+
+
+def test_telescope_constructor_threads_kwargs_cooperatively() -> None:
+    telescope = AlpacaTelescope(
+        settle_time=1.5,
+        fits_namespaces={"instrument": None},
+        **{**_DEVICE_ARGS, "device_type": "telescope"},
+    )
+    assert telescope.motion_status() == MotionStatus.UNKNOWN
+    assert telescope._FitsNamespaceMixin__namespaces == {"instrument": None}  # type: ignore[attr-defined]

pyobs_alpaca-2.0.0.dev5/tests/test_device.py

@@ -0,0 +1,68 @@
+"""Unit tests for the pure, non-hardware logic in AlpacaDevice.
+
+Hardware I/O (open/close, talking to the ASCOM server) is out of scope here; these cover
+URL construction, version validation, the connection guard, and the connected-state
+transition logic.
+"""
+
+from typing import Any
+
+import pytest
+
+from pyobs_alpaca.device import AlpacaDevice
+
+_ARGS = dict(server="myserver", port=11111, device_type="telescope", device=3)
+
+
+def test_build_alpaca_url() -> None:
+    device = AlpacaDevice(**_ARGS)
+    assert device._build_alpaca_url("RightAscension") == ("http://myserver:11111/api/v1/telescope/3/rightascension")
+
+
+def test_only_v1_supported() -> None:
+    with pytest.raises(ValueError):
+        AlpacaDevice(**_ARGS, version="v2")
+
+
+def test_starts_disconnected() -> None:
+    device = AlpacaDevice(**_ARGS)
+    assert device.connected is False
+
+
+@pytest.mark.asyncio
+async def test_get_requires_connection() -> None:
+    device = AlpacaDevice(**_ARGS)
+    with pytest.raises(ConnectionError):
+        await device.get("RightAscension")
+
+
+@pytest.mark.asyncio
+async def test_put_requires_connection() -> None:
+    device = AlpacaDevice(**_ARGS)
+    with pytest.raises(ConnectionError):
+        await device.put("Tracking", Tracking=False)
+
+
+@pytest.mark.asyncio
+async def test_check_connected_sets_flag_on_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    device = AlpacaDevice(**_ARGS)
+
+    async def fake_get(name: str) -> Any:
+        return True
+
+    monkeypatch.setattr(device, "_get", fake_get)
+    await device._check_connected()
+    assert device.connected is True
+
+
+@pytest.mark.asyncio
+async def test_check_connected_clears_flag_on_connection_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    device = AlpacaDevice(**_ARGS)
+    device._connected = True
+
+    async def fake_get(name: str) -> Any:
+        raise ConnectionError
+
+    monkeypatch.setattr(device, "_get", fake_get)
+    await device._check_connected()
+    assert device.connected is False

pyobs_alpaca-2.0.0.dev5/tests/test_import.py

@@ -0,0 +1,47 @@
+"""Smoke tests: import every public module and instantiate each driver class with a
+missing/mocked hardware connection, asserting it loads and advertises the interfaces it
+claims.
+
+No real hardware or ASCOM server is involved: instantiation only registers background
+tasks, which never start until open() is called.
+"""
+
+from pyobs.interfaces import (
+    IDome,
+    IFitsHeaderBefore,
+    IFocuser,
+    IOffsetsRaDec,
+    ISyncTarget,
+    ITelescope,
+)
+from pyobs.object import Object
+
+from pyobs_alpaca import AlpacaDome, AlpacaFocuser, AlpacaTelescope
+from pyobs_alpaca.device import AlpacaDevice
+
+_TELESCOPE_ARGS = dict(server="localhost", port=11111, device_type="telescope", device=0)
+
+
+def test_import_device_and_instantiate() -> None:
+    device = AlpacaDevice(**_TELESCOPE_ARGS)
+    assert isinstance(device, Object)
+    assert not device.connected
+
+
+def test_import_telescope_and_instantiate() -> None:
+    telescope = AlpacaTelescope(**_TELESCOPE_ARGS)
+    assert isinstance(telescope, ITelescope)
+    assert isinstance(telescope, IFitsHeaderBefore)
+    assert isinstance(telescope, IOffsetsRaDec)
+    assert isinstance(telescope, ISyncTarget)
+
+
+def test_import_focuser_and_instantiate() -> None:
+    focuser = AlpacaFocuser(server="localhost", port=11111, device_type="focuser", device=0)
+    assert isinstance(focuser, IFocuser)
+    assert isinstance(focuser, IFitsHeaderBefore)
+
+
+def test_import_dome_and_instantiate() -> None:
+    dome = AlpacaDome(server="localhost", port=11111, device_type="dome", device=0)
+    assert isinstance(dome, IDome)