pyobs-alpaca 1.1.2__tar.gz → 2.0.0.dev2__tar.gz

pyobs_alpaca-2.0.0.dev2/.github/workflows/ruff.yml

@@ -0,0 +1,23 @@
+name: ruff
+on: push
+
+jobs:
+  ruff:
+    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 ruff
+        run: uv run --no-sync ruff check pyobs_alpaca/

pyobs_alpaca-2.0.0.dev2/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 25.1.0
+    hooks:
+      - id: black
+        language_version: python3.11
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.0
+    hooks:
+      - id: ruff

{pyobs_alpaca-1.1.2 → pyobs_alpaca-2.0.0.dev2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: pyobs-alpaca
-Version: 1.1.2
+Version: 2.0.0.dev2
 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<2,>=1
+Requires-Dist: pyobs-core<3,>=2.0.0.dev1

pyobs_alpaca-2.0.0.dev2/pyobs_alpaca/__init__.py

@@ -0,0 +1,3 @@
+from .dome import AlpacaDome as AlpacaDome
+from .focuser import AlpacaFocuser as AlpacaFocuser
+from .telescope import AlpacaTelescope as AlpacaTelescope

{pyobs_alpaca-1.1.2 → pyobs_alpaca-2.0.0.dev2}/pyobs_alpaca/device.py

@@ -1,8 +1,8 @@
 import asyncio
 import logging
 from typing import Any, NamedTuple
-import aiohttp
 
+import aiohttp
 from pyobs.object import Object
 
 log = logging.getLogger("pyobs")
@@ -112,14 +112,7 @@ class AlpacaDevice(Object):
         Returns:
             Full Alpaca URL
         """
-        return "http://%s:%d/api/%s/%s/%d/%s" % (
-            self._server,
-            self._port,
-            self._version,
-            self._type,
-            self._device,
-            name.lower(),
-        )
+        return f"http://{self._server}:{self._port}/api/{self._version}/{self._type}/{self._device}/{name.lower()}"
 
     async def _get(self, name: str) -> Any:
         """Calls GET on Alpaca server, which returns value for variable with given name.
@@ -140,7 +133,7 @@ class AlpacaDevice(Object):
         # request it
         try:
             async with aiohttp.ClientSession() as session:
-                async with session.get(url, timeout=5) as response:
+                async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as response:
                     if response.status != 200:
                         raise ConnectionError(
                             f"ALPACA server responded with error {response.status}: {await response.text()}."
@@ -148,13 +141,13 @@ class AlpacaDevice(Object):
                     json = await response.json()
                     resp = ServerGetResponse(**json)
 
-        except asyncio.TimeoutError:
+        except TimeoutError:
             # raise a ConnectionError instead
             raise ConnectionError("Connection to ALPACA server timed out.")
 
         # check error
         if resp.ErrorNumber != 0:
-            raise ConnectionError("Server error: %s" % resp.ErrorMessage)
+            raise ConnectionError(f"Server error: {resp.ErrorMessage}")
 
         # return value
         return resp.Value
@@ -177,7 +170,7 @@ class AlpacaDevice(Object):
             raise ConnectionError("Not connected to ASCOM.")
         return await self._get(name)
 
-    async def put(self, name: str, timeout: float = 5, **values: Any) -> None:
+    async def put(self, name: str, timeout: float = 5.0, **values: Any) -> None:
         """Calls PUT on Alpaca server with given variable, which might set a variable or call a method.
 
         Args:
@@ -199,7 +192,7 @@ class AlpacaDevice(Object):
         # request it
         try:
             async with aiohttp.ClientSession() as session:
-                async with session.put(url, data=values, timeout=timeout) as response:
+                async with session.put(url, data=values, timeout=aiohttp.ClientTimeout(total=timeout)) as response:
                     if response.status != 200:
                         raise ConnectionError(
                             f"ALPACA server responded with error {response.status}: {await response.text()}."
@@ -207,13 +200,13 @@ class AlpacaDevice(Object):
                     json = await response.json()
                     resp = ServerPutResponse(**json)
 
-        except asyncio.TimeoutError:
+        except TimeoutError:
             # raise a ConnectionError instead
             raise ConnectionError("Connection to ALPACA server timed out.")
 
         # check error
         if resp.ErrorNumber != 0:
-            raise ConnectionError("Server error: %s" % resp.ErrorMessage)
+            raise ConnectionError(f"Server error: {resp.ErrorMessage}")
 
 
 __all__ = ["AlpacaDevice"]

{pyobs_alpaca-1.1.2 → pyobs_alpaca-2.0.0.dev2}/pyobs_alpaca/dome.py

@@ -1,17 +1,18 @@
 import asyncio
 import logging
 import time
-from typing import Tuple, Optional, Any
+from typing import Any
 
-from pyobs.events import RoofOpenedEvent, RoofClosingEvent
+from pyobs.events import RoofClosingEvent, RoofOpenedEvent
+from pyobs.interfaces import AltAzState, IPointingAltAz, IReady, ReadyState
 from pyobs.mixins import FollowMixin
-from pyobs.interfaces import IPointingAltAz
 from pyobs.modules import timeout
 from pyobs.modules.roof import BaseDome
+from pyobs.utils import exceptions as exc
 from pyobs.utils.enums import MotionStatus
 from pyobs.utils.parallel import event_wait
 from pyobs.utils.threads import LockWithAbort
-from pyobs.utils import exceptions as exc
+
 from .device import AlpacaDevice
 
 log = logging.getLogger("pyobs")
@@ -20,8 +21,8 @@ log = logging.getLogger("pyobs")
 class AlpacaDome(FollowMixin, BaseDome):
     __module__ = "pyobs_alpaca"
 
-    def __init__(self, tolerance: float = 3, park_az: float = 180, follow: Optional[str] = None, **kwargs: Any):
-        """Initializes a new ASCOM Alpaca telescope.
+    def __init__(self, tolerance: float = 3, park_az: float = 180, follow: str | None = None, **kwargs: Any):
+        """Initializes a new ASCOM Alpaca dome.
 
         Args:
             tolerance: Tolerance for azimuth.
@@ -60,9 +61,8 @@ class AlpacaDome(FollowMixin, BaseDome):
     async def open(self) -> None:
         """Open module."""
         await BaseDome.open(self)
-
-        # init status to IDLE
         await self._change_motion_status(MotionStatus.IDLE)
+        await self.comm.set_state(IReady, ReadyState(ready=self._device.connected))
 
     async def _send_open_dome(self) -> None:
         """Send command to open dome."""
@@ -74,40 +74,28 @@ class AlpacaDome(FollowMixin, BaseDome):
 
     @timeout(1200000)
     async def init(self, **kwargs: Any) -> None:
-        """Open dome.
+        """Open dome."""
 
-        Raises:
-            pyobs.utils.exceptions.InitError: If dome cannot be opened.
-        """
-
-        # weather?
         if not self.is_weather_good():
             raise exc.InitError("Weather seems to be bad.")
 
-        # if already opening, ignore
-        if await self.get_motion_status() == MotionStatus.INITIALIZING:
+        if self.motion_status() == MotionStatus.INITIALIZING:
             return
 
-        # acquire lock
         async with LockWithAbort(self._lock_shutter, self._abort_shutter):
-            # log
             log.info("Opening dome...")
             await self._change_motion_status(MotionStatus.INITIALIZING)
 
-            # execute command
             await self._send_open_dome()
             time_attempt = time.time()
 
-            # wait for it
             status = None
             while status != 0:
-                # error?
                 if status == 4:
                     log.error("Could not open dome.")
                     await self._change_motion_status(MotionStatus.UNKNOWN)
                     return
 
-                # wait a little and update
                 await event_wait(self._abort_shutter, 1)
                 try:
                     status = await self._device.get("ShutterStatus")
@@ -115,18 +103,16 @@ class AlpacaDome(FollowMixin, BaseDome):
                     await self._change_motion_status(MotionStatus.UNKNOWN)
                     raise exc.InitError("Could not open dome.")
 
-                # waited >10s?
                 if time.time() - time_attempt > 10:
                     await self._send_open_dome()
                     time_attempt = time.time()
 
-            # set new status
             log.info("Dome opened.")
             await self._change_motion_status(MotionStatus.POSITIONED)
             await self.comm.send_event(RoofOpenedEvent())
 
     async def _send_close_dome(self) -> None:
-        """Send command to open dome."""
+        """Send command to close dome."""
         try:
             await self._device.put("CloseShutter")
             await self._device.put("SlewToAzimuth", Azimuth=0)
@@ -136,37 +122,26 @@ class AlpacaDome(FollowMixin, BaseDome):
 
     @timeout(1200000)
     async def park(self, **kwargs: Any) -> None:
-        """Close dome.
+        """Close dome."""
 
-        Raises:
-            pyobs.utils.exceptions.ParkError: If dome cannot be opened.
-        """
-
-        # if already closing, ignore
-        if await self.get_motion_status() == MotionStatus.PARKING:
+        if self.motion_status() == MotionStatus.PARKING:
             return
 
-        # acquire lock
         async with LockWithAbort(self._lock_shutter, self._abort_shutter):
-            # log
             log.info("Closing dome...")
             await self._change_motion_status(MotionStatus.PARKING)
             await self.comm.send_event(RoofClosingEvent())
 
-            # send command for closing shutter and rotate to South
             await self._send_close_dome()
             time_attempt = time.time()
 
-            # wait for it
             status = None
             while status != 1:
-                # error?
                 if status == 4:
                     log.error("Could not close dome.")
                     await self._change_motion_status(MotionStatus.UNKNOWN)
                     raise exc.ParkError("Could not close dome.")
 
-                # wait a little and update
                 await event_wait(self._abort_shutter, 1)
                 try:
                     status = await self._device.get("ShutterStatus")
@@ -174,41 +149,27 @@ class AlpacaDome(FollowMixin, BaseDome):
                     await self._change_motion_status(MotionStatus.UNKNOWN)
                     raise exc.ParkError("Could not close dome.")
 
-                # waited >10s?
                 if time.time() - time_attempt > 10:
                     await self._send_close_dome()
                     time_attempt = time.time()
 
-            # set new status
             log.info("Dome closed.")
             await self._change_motion_status(MotionStatus.PARKED)
 
     async def _move(self, az: float, abort: asyncio.Event) -> None:
-        """Move the roof and wait for it.
-
-        Args:
-            az: Azimuth to move to.
-            abort: Abort event.
-
-        Raises:
-            pyobs.utils.exceptions.MoveError: If dome cannot be moved.
-        """
+        """Move the dome to the given azimuth."""
 
-        # execute command
         try:
             await self._device.put("SlewToAzimuth", Azimuth=self._adjust_azimuth(az))
         except ConnectionError:
             await self._change_motion_status(MotionStatus.UNKNOWN)
             raise exc.MoveError("Could not move dome.")
 
-        # wait for it
         log_timer = 0
         while 180 - abs(abs(az - self._azimuth) - 180) > self._tolerance:
-            # abort?
             if abort.is_set():
                 raise InterruptedError("Moving dome aborted.")
 
-            # log?
             if log_timer == 0:
                 log.info(
                     "Moving dome from current az=%.2f° to %.2f° (%.2f° left)...",
@@ -216,117 +177,68 @@ class AlpacaDome(FollowMixin, BaseDome):
                     az,
                     180 - abs(abs(az - self._azimuth) - 180),
                 )
-            log_timer += 1
-            if log_timer == 10:
-                log_timer = 0
+            log_timer = (log_timer + 1) % 10
 
-            # wait a little
             await event_wait(abort, 1)
 
-        # finished
         log.info("Moved to az=%.2f.", az)
 
     @timeout(1200000)
     async def move_altaz(self, alt: float, az: float, **kwargs: Any) -> None:
-        """Moves to given coordinates.
+        """Moves to given coordinates."""
 
-        Args:
-            alt: Alt in deg to move to.
-            az: Az in deg to move to.
-
-        Raises:
-            pyobs.utils.exceptions.MoveError: If device could not be moved.
-        """
-
-        # do nothing, if not ready
-        if not await self.is_ready():
+        # do nothing if not ready
+        bad_states = [
+            MotionStatus.PARKED,
+            MotionStatus.INITIALIZING,
+            MotionStatus.PARKING,
+            MotionStatus.ERROR,
+            MotionStatus.UNKNOWN,
+        ]
+        if not self._device.connected or self.motion_status() in bad_states:
             return
 
-        # destination az already set?
         if az == self._set_az:
             return
         self._set_az = az
 
-        # is this a larger move?
         large_move = abs(az - self._azimuth) > 2.0 * self._tolerance
-
-        # decide, whether we're tracking or just slewing
         tracking = self.is_following and not large_move
 
-        # acquire lock
         async with LockWithAbort(self._lock_move, self._abort_move):
-            # store altitude
             self._altitude = alt
-
-            # change status to TRACKING or SLEWING, depending on whether we're tracking
             await self._change_motion_status(MotionStatus.TRACKING if tracking else MotionStatus.SLEWING)
-
-            # move dome
             await self._move(az, self._abort_move)
-
-            # change status to TRACKING or POSITIONED, depending on whether we're tracking
             await self._change_motion_status(MotionStatus.TRACKING if self.is_following else MotionStatus.POSITIONED)
 
-    async def get_altaz(self, **kwargs: Any) -> Tuple[float, float]:
-        """Returns current Alt and Az.
-
-        Returns:
-            Tuple of current Alt and Az in degrees.
-        """
-        return self._altitude, self._azimuth
-
-    async def stop_motion(self, device: Optional[str] = None, **kwargs: Any) -> None:
-        """Stop the motion.
-
-        Args:
-            device: Name of device to stop, or None for all.
-        """
-
-        # not supported, but don't want to raise an exception
+    async def stop_motion(self, device: str | None = None, **kwargs: Any) -> None:
+        """Stop the motion."""
         pass
 
-    async def is_ready(self, **kwargs: Any) -> bool:
-        """Returns the device is "ready", whatever that means for the specific device.
-
-        Returns:
-            Whether device is ready
-        """
-
-        # check that motion is not in one of the states listed below
-        states = [
-            MotionStatus.PARKED,
-            MotionStatus.INITIALIZING,
-            MotionStatus.PARKING,
-            MotionStatus.ERROR,
-            MotionStatus.UNKNOWN,
-        ]
-        return self._device.connected and await self.get_motion_status() not in states
-
     async def _update_status(self) -> None:
         """Update status from dome."""
-
-        # loop forever
         while True:
-            # get azimuth
             try:
                 self._azimuth = self._adjust_azimuth(await self._device.get("Azimuth"))
+                await self.comm.set_state(IPointingAltAz, AltAzState(alt=self._altitude, az=self._azimuth))
             except ConnectionError:
-                # ignore it
                 pass
 
-            # sleep a little
+            bad_states = [
+                MotionStatus.PARKED,
+                MotionStatus.INITIALIZING,
+                MotionStatus.PARKING,
+                MotionStatus.ERROR,
+                MotionStatus.UNKNOWN,
+            ]
+            ready = self._device.connected and self.motion_status() not in bad_states
+            await self.comm.set_state(IReady, ReadyState(ready=ready))
+
             await asyncio.sleep(2)
 
     @staticmethod
     def _adjust_azimuth(az: float) -> float:
-        """Baader measures azimuth as West of South, so we need to convert it. This works both ways.
-
-        Args:
-            az: Azimuth.
-
-        Returns:
-            Converted azimuth.
-        """
+        """Baader measures azimuth as West of South — convert both ways."""
         az += 180
         if az >= 360:
             az -= 360

{pyobs_alpaca-1.1.2 → pyobs_alpaca-2.0.0.dev2}/pyobs_alpaca/focuser.py

@@ -1,14 +1,14 @@
 import asyncio
 import logging
-from typing import List, Dict, Tuple, Any, Optional
+from typing import Any
 
-from pyobs.modules import Module
-from pyobs.interfaces import IFocuser, IFitsHeaderBefore
+from pyobs.interfaces import FocuserState, IFitsHeaderBefore, IFocuser, IReady, ReadyState
 from pyobs.mixins import MotionStatusMixin
-from pyobs.modules import timeout
+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 pyobs.utils import exceptions as exc
+
 from .device import AlpacaDevice
 
 log = logging.getLogger(__name__)
@@ -45,166 +45,83 @@ class AlpacaFocuser(MotionStatusMixin, IFocuser, IFitsHeaderBefore, Module):
 
         # init status
         await self._change_motion_status(MotionStatus.IDLE, interface="IFocuser")
+        await self.comm.set_state(IReady, ReadyState(ready=self._device.connected))
 
     async def init(self, **kwargs: Any) -> None:
-        """Initialize device.
-
-        Raises:
-            pyobs.utils.exceptions.InitError: If device could not be initialized.
-        """
+        """Initialize device."""
         pass
 
     async def park(self, **kwargs: Any) -> None:
-        """Park device.
-
-        Raises:
-            pyobs.utils.exceptions.ParkError: If device could not be parked.
-        """
+        """Park device."""
         pass
 
     async def get_fits_header_before(
-        self, namespaces: Optional[List[str]] = None, **kwargs: Any
-    ) -> Dict[str, Tuple[Any, str]]:
-        """Returns FITS header for the current status of this module.
-
-        Args:
-            namespaces: If given, only return FITS headers for the given namespaces.
+        self, namespaces: list[str] | None = None, **kwargs: Any
+    ) -> dict[str, tuple[Any, str]]:
+        """Returns FITS header for the current status of this module."""
 
-        Returns:
-            Dictionary containing FITS headers.
-        """
-
-        # get pos and step size
-        # StepSize is in microns, so multiply with 1000
         try:
             pos = await self._device.get("Position")
             step = await self._device.get("StepSize") * 1000.0
-
-            # return header
             return {"TEL-FOCU": (pos / step, "Focus of telescope [mm]")}
-
         except ConnectionError as e:
             log.warning("Could not determine focus position: %s", e)
             return {}
 
     @timeout(60000)
     async def set_focus(self, focus: float, **kwargs: Any) -> None:
-        """Sets new focus.
-
-        Raises:
-            pyobs.utils.exceptions.MoveError: If telescope cannot be moved.
-        """
-
-        # set focus + offset
-
+        """Sets new focus."""
         await self._set_focus(focus + self._focus_offset)
 
     async def set_focus_offset(self, offset: float, **kwargs: Any) -> None:
-        """Sets focus offset.
+        """Sets focus offset."""
 
-        Args:
-            offset: New focus offset.
-
-        Raises:
-            InterruptedError: If focus was interrupted.
-        """
-
-        # get current focus (without offset)
-        focus = await self.get_focus()
+        # get current focus (without offset) directly from device
+        try:
+            pos = float(await self._device.get("Position"))
+            step = float(await self._device.get("StepSize")) * 1000.0
+            current_focus = pos / step - self._focus_offset
+        except ConnectionError:
+            raise exc.MoveError("Could not read focus position.")
 
-        # set offset
         self._focus_offset = offset
-
-        # go to focus
-        await self._set_focus(focus + self._focus_offset)
+        await self._set_focus(current_focus + self._focus_offset)
 
     async def _set_focus(self, focus: float) -> None:
-        """Actually sets new focus.
+        """Actually sets new focus."""
 
-        Args:
-            focus: New focus value.
-        """
-
-        # acquire lock
         async with LockWithAbort(self._lock_motion, self._abort_motion):
             try:
-                # get step size
                 step = await self._device.get("StepSize")
 
-                # calculating new focus and move it
                 log.info("Moving focus to %.2fmm...", focus)
                 await self._change_motion_status(MotionStatus.SLEWING, interface="IFocuser")
                 foc = int(focus * step * 1000.0)
                 await self._device.put("Move", Position=foc)
 
-                # wait for it
                 while abs(await self._device.get("Position") - foc) > 10:
-                    # abort?
                     if self._abort_motion.is_set():
                         await self._device.put("Halt")
                         await self._change_motion_status(MotionStatus.POSITIONED, interface="IFocuser")
                         raise InterruptedError("Setting focus aborted.")
-
-                    # sleep a little
                     await asyncio.sleep(0.1)
 
-                # finished
-                log.info("Reached new focus of %.2fmm.", await self._device.get("Position") / step / 1000.0)
+                pos = await self._device.get("Position")
+                log.info("Reached new focus of %.2fmm.", pos / step / 1000.0)
                 await self._change_motion_status(MotionStatus.POSITIONED, interface="IFocuser")
 
+                # publish new state
+                await self.comm.set_state(
+                    IFocuser, FocuserState(focus=pos / step / 1000.0, focus_offset=self._focus_offset)
+                )
+
             except ConnectionError:
                 await self._change_motion_status(MotionStatus.ERROR, interface="IFocuser")
                 raise exc.MoveError("Could not move focus.")
 
-    async def get_focus(self, **kwargs: Any) -> float:
-        """Return current focus.
-
-        Returns:
-            Current focus.
-        """
-
-        # get pos and step size
-        # StepSize is in microns, so multiply with 1000
-        pos = float(await self._device.get("Position"))
-        step = float(await self._device.get("StepSize")) * 1000.0
-
-        # return current focus - offset
-        return pos / step - self._focus_offset
-
-    async def get_focus_offset(self, **kwargs: Any) -> float:
-        """Return current focus offset.
-
-        Returns:
-            Current focus offset.
-        """
-        return self._focus_offset
-
-    async def stop_motion(self, device: Optional[str] = None, **kwargs: Any) -> None:
-        """Stop the motion.
-
-        Args:
-            device: Name of device to stop, or None for all.
-        """
-
-        # stop motion
+    async def stop_motion(self, device: str | None = None, **kwargs: Any) -> None:
+        """Stop the motion."""
         await self._device.put("Halt")
 
-    async def is_ready(self, **kwargs: Any) -> bool:
-        """Returns the device is "ready", whatever that means for the specific device.
-
-        Returns:
-            True, if telescope is initialized and not in an error state.
-        """
-
-        # check that motion is not in one of the states listed below
-        states = [
-            MotionStatus.PARKED,
-            MotionStatus.INITIALIZING,
-            MotionStatus.PARKING,
-            MotionStatus.ERROR,
-            MotionStatus.UNKNOWN,
-        ]
-        return self._device.connected and await self.get_motion_status() not in states
-
 
 __all__ = ["AlpacaFocuser"]