pyobs-core 2.0.0.dev11__py3-none-any.whl → 2.0.0.dev13__py3-none-any.whl

pyobs/comm/xmpp/xmppcomm.py

@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any
 
 import slixmpp
 import slixmpp.exceptions
-from slixmpp import ElementBase
+from slixmpp import JID, ElementBase
 from slixmpp.xmlstream import ET
 from slixmpp.xmlstream.handler import Callback
 from slixmpp.xmlstream.matcher import MatchXMLMask
@@ -382,7 +382,7 @@ class XmppComm(Comm):
 
         # request features
         try:
-            info = await self._safe_send(self.client["xep_0030"].get_info, jid=jid, cached=False)
+            info = await self._safe_send(self.client.plugin["xep_0030"].get_info, jid=jid, cached=False)
         except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
             return []
 
@@ -679,7 +679,7 @@ class XmppComm(Comm):
 
         # send it
         await self._safe_send(
-            self.client["xep_0163"].publish,
+            self.client.plugin["xep_0163"].publish,
             stanza,
             node=f"urn:pyobs:event:{event.__class__.__name__}:{event.version}",
             callback=functools.partial(self._send_event_callback, event=event),
@@ -705,15 +705,15 @@ class XmppComm(Comm):
         # loop events
         for ev in events:
             # register event at XMPP
-            self.client["xep_0030"].add_feature(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
+            self.client.plugin["xep_0030"].add_feature(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
 
             # if we have a handler, we're also interested in receiving such events
             if handler:
                 # add interest
-                self.client["xep_0163"].add_interest(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
+                self.client.plugin["xep_0163"].add_interest(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
 
         # update caps and send presence
-        await self._safe_send(self.client["xep_0115"].update_caps)
+        await self._safe_send(self.client.plugin["xep_0115"].update_caps)
         self.client.send_presence()
 
     def _handle_event_sync(self, msg: Any) -> None:
@@ -779,7 +779,7 @@ class XmppComm(Comm):
         # send it to module
         self._send_event_to_module(event, msg["from"].username)
 
-    async def _safe_send(self, method: Callable[[Any], Coroutine[Any, Any, None]], *args: Any, **kwargs: Any) -> Any:
+    async def _safe_send(self, method: Callable[..., Coroutine[Any, Any, Any]], *args: Any, **kwargs: Any) -> Any:
         """Safely send an XMPP message.
 
         Args:
@@ -827,7 +827,9 @@ class XmppComm(Comm):
         retract stanza or a node whose deliver_payloads flag is off.
         """
         try:
-            result = await self._safe_send(self.client["xep_0060"].get_items, self._pubsub_service, node, max_items=1)
+            result = await self._safe_send(
+                self.client.plugin["xep_0060"].get_items, self._pubsub_service, node, max_items=1
+            )
             # Use raw XML to avoid lazy-loading issues with plugin_multi_attrib
             pubsub_ns = "http://jabber.org/protocol/pubsub"
             pubsub_xml = result.xml.find(f"{{{pubsub_ns}}}pubsub")
@@ -847,7 +849,7 @@ class XmppComm(Comm):
         node = self._state_node(self._module.name, interface)  # type: ignore[union-attr]
         stanza = StateStanza()
         stanza.xml = _dataclass_to_xml(state, self._state_namespace(interface))
-        await self._safe_send(self.client["xep_0060"].publish, self._pubsub_service, node, payload=stanza)
+        await self._safe_send(self.client.plugin["xep_0060"].publish, self._pubsub_service, node, payload=stanza)
 
     async def _get_disco_info(self, jid, node, ifrom, data):
         """Custom disco#info handler that adds <capability> elements for static module values."""
@@ -906,7 +908,7 @@ class XmppComm(Comm):
         jid = full_jid
         ns = f"urn:pyobs:capabilities:{interface.__name__}:{interface.version}"
         try:
-            result = await asyncio.wait_for(self.client["xep_0030"].get_info(jid=jid), timeout=10.0)
+            result = await asyncio.wait_for(self.client.plugin["xep_0030"].get_info(jid=JID(jid)), timeout=10.0)
         except (TimeoutError, Exception) as e:
             log.warning("Failed to get capabilities for %s from %s: %s", interface.__name__, module, e)
             return None
@@ -957,7 +959,7 @@ class XmppComm(Comm):
         """
         for _attempt in range(30):
             try:
-                await self._safe_send(self.client["xep_0060"].subscribe, self._pubsub_service, node)
+                await self._safe_send(self.client.plugin["xep_0060"].subscribe, self._pubsub_service, node)
                 break
             except slixmpp.exceptions.IqError:
                 await asyncio.sleep(1)
@@ -967,7 +969,9 @@ class XmppComm(Comm):
 
         # Fetch current value immediately after subscribing
         try:
-            result = await self._safe_send(self.client["xep_0060"].get_items, self._pubsub_service, node, max_items=1)
+            result = await self._safe_send(
+                self.client.plugin["xep_0060"].get_items, self._pubsub_service, node, max_items=1
+            )
             pubsub_ns = "http://jabber.org/protocol/pubsub"
             pubsub_xml = result.xml.find(f"{{{pubsub_ns}}}pubsub")
             items_xml = pubsub_xml.find(f"{{{pubsub_ns}}}items") if pubsub_xml is not None else None
@@ -1011,7 +1015,7 @@ class XmppComm(Comm):
                 # Last subscriber — unsubscribe from ejabberd and remove handler
                 del self._state_node_handlers[node]
                 try:
-                    await self._safe_send(self.client["xep_0060"].unsubscribe, self._pubsub_service, node)
+                    await self._safe_send(self.client.plugin["xep_0060"].unsubscribe, self._pubsub_service, node)
                 except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
                     pass  # already gone server-side
 

pyobs/interfaces/IAcquisition.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Annotated, Any
 
-from ..utils.enums import Unit
+from ..utils.enums import OffsetFrame, Unit
 from ..utils.time import Time
 from .IAbortable import IAbortable
 from .IRunning import IRunning
@@ -17,10 +17,28 @@ class AcquisitionResult:
     dec: Annotated[float, Unit.DEGREES]
     alt: Annotated[float, Unit.DEGREES]
     az: Annotated[float, Unit.DEGREES]
-    off_ra: Annotated[float, Unit.DEGREES] | None = None
-    off_dec: Annotated[float, Unit.DEGREES] | None = None
-    off_alt: Annotated[float, Unit.DEGREES] | None = None
-    off_az: Annotated[float, Unit.DEGREES] | None = None
+    offset_frame: OffsetFrame | None = None
+    # (ra, dec) if offset_frame is RA_DEC, (alt, az) if ALT_AZ
+    offset_lon: Annotated[float, Unit.DEGREES] | None = None
+    offset_lat: Annotated[float, Unit.DEGREES] | None = None
+
+
+@dataclass
+class AcquisitionAttempt:  # AcquisitionState.attempts element
+    attempt: int
+    distance: Annotated[float, Unit.ARCSEC]
+    offset_applied: bool
+    # accumulated telescope offset after this attempt; (ra, dec) if offset_frame is RA_DEC, (alt, az) if ALT_AZ
+    offset_frame: OffsetFrame | None = None
+    offset_lon: Annotated[float, Unit.DEGREES] | None = None
+    offset_lat: Annotated[float, Unit.DEGREES] | None = None
+
+
+@dataclass
+class AcquisitionState:  # growing log of attempts during an acquisition run
+    attempts: list[AcquisitionAttempt] = field(default_factory=list)
+    result: AcquisitionResult | None = None
+    time: Time = field(default_factory=Time.now)
 
 
 class IAcquisition(IRunning, IAbortable, metaclass=ABCMeta):
@@ -28,6 +46,8 @@ class IAcquisition(IRunning, IAbortable, metaclass=ABCMeta):
 
     __module__ = "pyobs.interfaces"
 
+    state = AcquisitionState
+
     @abstractmethod
     async def acquire_target(self, **kwargs: Any) -> AcquisitionResult:
         """Acquire target at given coordinates.
@@ -36,7 +56,7 @@ class IAcquisition(IRunning, IAbortable, metaclass=ABCMeta):
         coordinates.
 
         Returns:
-            Result with time, ra, dec, alt, az, and either off_ra/off_dec or off_alt/off_az offsets.
+            Result with time, ra, dec, alt, az, and an offset in whichever frame the mount supports.
 
         Raises:
             ValueError: If target could not be acquired.
@@ -44,4 +64,4 @@ class IAcquisition(IRunning, IAbortable, metaclass=ABCMeta):
         ...
 
 
-__all__ = ["AcquisitionResult", "IAcquisition"]
+__all__ = ["AcquisitionResult", "AcquisitionAttempt", "AcquisitionState", "OffsetFrame", "IAcquisition"]

pyobs/interfaces/IAutoFocus.py

@@ -7,6 +7,7 @@ from typing import Annotated, Any
 from ..utils.enums import Unit
 from ..utils.time import Time
 from .IAbortable import IAbortable
+from .IRunning import IRunning
 
 
 @dataclass
@@ -27,7 +28,7 @@ class AutoFocusState:  # growing curve during autofocus run
     time: Time = field(default_factory=Time.now)
 
 
-class IAutoFocus(IAbortable, metaclass=ABCMeta):
+class IAutoFocus(IRunning, IAbortable, metaclass=ABCMeta):
     """The module can perform an autofocus."""
 
     __module__ = "pyobs.interfaces"

pyobs/interfaces/IAutoGuiding.py

@@ -1,13 +1,31 @@
+from __future__ import annotations
+
 from abc import ABCMeta
+from dataclasses import dataclass, field
+from typing import Annotated
 
+from ..utils.enums import OffsetFrame, Unit
+from ..utils.time import Time
 from .IExposureTime import IExposureTime
 from .IStartStop import IStartStop
 
 
+@dataclass
+class GuidingState:  # live open/closed-loop status, separate from the per-session FITS-header RMS stats
+    loop_closed: bool = False
+    # the correction applied for the last processed image, in the mount's native frame
+    offset_frame: OffsetFrame | None = None
+    offset_lon: Annotated[float, Unit.DEGREES] | None = None
+    offset_lat: Annotated[float, Unit.DEGREES] | None = None
+    time: Time = field(default_factory=Time.now)
+
+
 class IAutoGuiding(IStartStop, IExposureTime, metaclass=ABCMeta):
     """The module can perform auto-guiding."""
 
     __module__ = "pyobs.interfaces"
 
+    state = GuidingState
+
 
-__all__ = ["IAutoGuiding"]
+__all__ = ["IAutoGuiding", "GuidingState"]

pyobs/interfaces/IMode.py

@@ -28,15 +28,15 @@ class IMode(Interface, metaclass=ABCMeta):
     capabilities = ModeCapabilities
 
     @abstractmethod
-    async def set_mode(self, mode: str, group: int = 0, **kwargs: Any) -> None:
+    async def set_mode(self, mode: str, group: str = "", **kwargs: Any) -> None:
         """Set the current mode.
 
         Args:
             mode: Name of mode to set.
-            group: Group number
+            group: Name of the group to set the mode for.
 
         Raises:
-            ValueError: If an invalid mode was given.
+            ValueError: If an invalid mode or group was given.
             MoveError: If mode selector cannot be moved.
         """
         ...

pyobs/interfaces/__init__.py

@@ -11,10 +11,11 @@ implement :class:`~pyobs.interfaces.ICamera`.
 
 __title__ = "Interfaces"
 
+from ..utils.enums import OffsetFrame
 from .IAbortable import IAbortable
-from .IAcquisition import AcquisitionResult, IAcquisition
+from .IAcquisition import AcquisitionAttempt, AcquisitionResult, AcquisitionState, IAcquisition
 from .IAutoFocus import AutoFocusPoint, AutoFocusResult, AutoFocusState, IAutoFocus
-from .IAutoGuiding import IAutoGuiding
+from .IAutoGuiding import GuidingState, IAutoGuiding
 from .IAutonomous import IAutonomous
 from .IBinning import Binning, BinningCapabilities, BinningState, IBinning
 from .ICalibrate import ICalibrate
@@ -64,12 +65,16 @@ from .IWindow import IWindow, WindowCapabilities, WindowState
 __all__ = [
     "IAbortable",
     "AcquisitionResult",
+    "AcquisitionAttempt",
+    "AcquisitionState",
+    "OffsetFrame",
     "IAcquisition",
     "IAutoFocus",
     "AutoFocusResult",
     "AutoFocusPoint",
     "AutoFocusState",
     "IAutoGuiding",
+    "GuidingState",
     "IAutonomous",
     "Binning",
     "IBinning",

pyobs/modules/focus/__init__.py

@@ -5,7 +5,8 @@ TODO: write doc
 
 __title__ = "Focus"
 
+from .dummyautofocus import DummyAutoFocus
 from .focusmodel import FocusModel
 from .focusseries import AutoFocusSeries
 
-__all__ = ["FocusModel", "AutoFocusSeries"]
+__all__ = ["FocusModel", "AutoFocusSeries", "DummyAutoFocus"]

pyobs/modules/focus/dummyautofocus.py

@@ -0,0 +1,111 @@
+import asyncio
+import logging
+import math
+import random
+from typing import Any
+
+from pyobs.events import FocusFoundEvent
+from pyobs.interfaces import IAutoFocus, IRunning
+from pyobs.interfaces.IAutoFocus import AutoFocusPoint, AutoFocusResult, AutoFocusState
+from pyobs.interfaces.IRunning import RunningState
+from pyobs.modules import Module
+from pyobs.utils import exceptions as exc
+
+log = logging.getLogger(__name__)
+
+
+class DummyAutoFocus(Module, IAutoFocus):
+    """Dummy class for auto-focusing a telescope."""
+
+    __module__ = "pyobs.modules.focus"
+
+    def __init__(
+        self,
+        wait_time: float = 0.5,
+        best_focus: float = 10.0,
+        min_value: float = 3.0,
+        curve_width: float = 0.0253,
+        **kwargs: Any,
+    ):
+        """Create a new dummy auto-focus.
+
+        Args:
+            wait_time: Time to wait between focus steps, in seconds.
+            best_focus: Focus value the series converges to.
+            min_value: Value (e.g. HFD) at the focus curve's minimum.
+            curve_width: Width parameter of the focus curve; with the defaults, a
+                count=5/step=0.1 series (the typical case) spans from min_value at the
+                centre to about 20 at the outer points.
+        """
+        Module.__init__(self, **kwargs)
+
+        self._wait_time = wait_time
+        self._best_focus = best_focus
+        self._min_value = min_value
+        self._curve_width = curve_width
+        self._running = False
+        self._abort = asyncio.Event()
+
+    async def open(self) -> None:
+        """Open module."""
+        await Module.open(self)
+        await self.comm.register_event(FocusFoundEvent)
+        await self.comm.set_state(IAutoFocus, AutoFocusState())
+        await self.comm.set_state(IRunning, RunningState(running=False))
+
+    async def auto_focus(self, count: int, step: float, exposure_time: float, **kwargs: Any) -> AutoFocusResult:
+        """Perform an autofocus series.
+
+        Args:
+            count: Number of images to take on each side of the initial guess.
+            step: Step size.
+            exposure_time: Exposure time for images.
+
+        Returns:
+            Result of autofocus.
+
+        Raises:
+            ValueError: If focus could not be obtained.
+        """
+
+        try:
+            self._running = True
+            self._abort = asyncio.Event()
+            await self.comm.set_state(IRunning, RunningState(running=True))
+            return await self._auto_focus(count, step)
+        finally:
+            self._running = False
+            await self.comm.set_state(IRunning, RunningState(running=False))
+
+    async def _auto_focus(self, count: int, step: float) -> AutoFocusResult:
+        # a real focus curve (HFD/FWHM vs. focus position) is a hyperbola, not a parabola:
+        # value(x) = sqrt(min_value^2 + ((x - best_focus) / curve_width)^2)
+        points: list[AutoFocusPoint] = []
+        await self.comm.set_state(IAutoFocus, AutoFocusState(points=points))
+
+        for i in range(-count, count + 1):
+            if self._abort.is_set():
+                raise exc.AbortedError()
+
+            focus = self._best_focus + i * step
+            value = math.sqrt(self._min_value**2 + ((focus - self._best_focus) / self._curve_width) ** 2)
+            value += random.gauss(0.0, self._min_value * 0.05)
+            points = points + [AutoFocusPoint(focus=focus, value=value)]
+            await self.comm.set_state(IAutoFocus, AutoFocusState(points=points))
+
+            await asyncio.sleep(self._wait_time)
+
+        error = abs(random.gauss(0.0, step / 10))
+        await self.comm.send_event(FocusFoundEvent(self._best_focus, error))
+        return AutoFocusResult(focus=self._best_focus, focus_err=error)
+
+    async def is_running(self, **kwargs: Any) -> bool:
+        """Whether a service is running."""
+        return self._running
+
+    async def abort(self, **kwargs: Any) -> None:
+        """Abort current actions."""
+        self._abort.set()
+
+
+__all__ = ["DummyAutoFocus"]

pyobs/modules/focus/focusseries.py

@@ -13,8 +13,10 @@ from pyobs.interfaces import (
     IFilters,
     IFocuser,
     IImageType,
+    IRunning,
 )
 from pyobs.interfaces.IAutoFocus import AutoFocusResult, AutoFocusState
+from pyobs.interfaces.IRunning import RunningState
 from pyobs.mixins import CameraSettingsMixin
 from pyobs.modules import Module, raises, timeout
 from pyobs.object import get_object
@@ -99,6 +101,7 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
 
         # publish initial states
         await self.comm.set_state(IAutoFocus, AutoFocusState())
+        await self.comm.set_state(IRunning, RunningState(running=False))
 
     @raises(exc.AbortedError, exc.FocusError)
     @timeout(600)
@@ -124,11 +127,13 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
         try:
             log.info("Performing auto-focus...")
             self._running = True
+            await self.comm.set_state(IRunning, RunningState(running=True))
             focus, error = await self._auto_focus(count, step, exposure_time, **kwargs)
             return AutoFocusResult(focus=focus, focus_err=error)
 
         finally:
             self._running = False
+            await self.comm.set_state(IRunning, RunningState(running=False))
 
     async def _auto_focus(self, count: int, step: float, exposure_time: float, **kwargs: Any) -> tuple[float, float]:
         # do camera settings
@@ -290,6 +295,10 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
         """Abort current actions."""
         self._abort.set()
 
+    async def is_running(self, **kwargs: Any) -> bool:
+        """Whether a service is running."""
+        return self._running
+
     async def _on_bad_weather(self, event: Event, sender: str) -> bool:
         """Abort series if a bad weather event occurs.
 

pyobs/modules/pointing/_baseguiding.py

@@ -8,7 +8,9 @@ import astropy.units as u
 from astropy.coordinates import SkyCoord
 
 from pyobs.images import Image
-from pyobs.interfaces import FitsHeaderEntry, IAutoGuiding, IFitsHeaderAfter, IFitsHeaderBefore
+from pyobs.interfaces import FitsHeaderEntry, GuidingState, IAutoGuiding, IFitsHeaderAfter, IFitsHeaderBefore, IRunning
+from pyobs.interfaces.IRunning import RunningState
+from pyobs.utils.enums import OffsetFrame
 from pyobs.utils.time import Time
 
 from ...interfaces import ITelescope
@@ -60,6 +62,9 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
         self._reset_at_focus = reset_at_focus
         self._reset_at_filter = reset_at_filter
         self._loop_closed = False
+        self._last_offset_frame: OffsetFrame | None = None
+        self._last_offset_lon: float | None = None
+        self._last_offset_lat: float | None = None
 
         # headers of last and of reference image
         self._last_header = None
@@ -72,15 +77,23 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
         self._statistics = get_object(guiding_statistic, GuidingStatistics)
         self._uptime = GuidingStatisticsUptime()
 
+    async def open(self) -> None:
+        """Open module."""
+        await BasePointing.open(self)
+        await self.comm.set_state(IRunning, RunningState(running=False))
+        await self.comm.set_state(IAutoGuiding, GuidingState())
+
     async def start(self, **kwargs: Any) -> None:
         """Starts/resets auto-guiding."""
         log.info("Start auto-guiding...")
         await self._reset_guiding(enabled=True)
+        await self.comm.set_state(IRunning, RunningState(running=True))
 
     async def stop(self, **kwargs: Any) -> None:
         """Stops auto-guiding."""
         log.info("Stopping auto-guiding...")
         await self._reset_guiding(enabled=False)
+        await self.comm.set_state(IRunning, RunningState(running=False))
 
     async def is_running(self, **kwargs: Any) -> bool:
         """Whether auto-guiding is running.
@@ -142,7 +155,7 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
             image: If given, new reference image.
         """
         self._enabled = enabled
-        self._set_loop_state(False)
+        await self._set_loop_state(False)
         self._ref_header = None if image is None else image.header
         self._last_header = None if image is None else image.header
 
@@ -152,9 +165,24 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
             # if image is given, process it
             await self.run_pipeline(image)
 
-    def _set_loop_state(self, state: bool) -> None:
+    async def _set_loop_state(
+        self, state: bool, frame: OffsetFrame | None = None, lon: float | None = None, lat: float | None = None
+    ) -> None:
         self._uptime.add_data(state)
         self._loop_closed = state
+        if frame is not None:
+            self._last_offset_frame = frame
+            self._last_offset_lon = lon
+            self._last_offset_lat = lat
+        await self.comm.set_state(
+            IAutoGuiding,
+            GuidingState(
+                loop_closed=state,
+                offset_frame=self._last_offset_frame,
+                offset_lon=self._last_offset_lon,
+                offset_lat=self._last_offset_lat,
+            ),
+        )
 
     async def _process_image(self, image: Image) -> Image | None:
         """Processes a single image and offsets telescope.
@@ -228,7 +256,7 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
         # exposure time too large?
         if self._max_exposure_time is not None and image.header["EXPTIME"] > self._max_exposure_time:
             log.warning("Exposure time too large, skipping auto-guiding for now...")
-            self._set_loop_state(False)
+            await self._set_loop_state(False)
             return None
 
         # remember header
@@ -243,21 +271,22 @@ class BaseGuiding(BasePointing, IAutoGuiding, IFitsHeaderBefore, IFitsHeaderAfte
         # get telescope
         if not await self.has_proxy(self._telescope, ITelescope):
             log.error("Given telescope does not exist or is not of correct type.")
-            self._set_loop_state(False)
+            await self._set_loop_state(False)
             return image
 
         # apply offsets
         try:
             async with self.proxy(self._telescope, ITelescope) as telescope:
-                if await self._apply(image, telescope, self._location):
-                    self._set_loop_state(True)
+                result = await self._apply(image, telescope, self._location)
+                if result.applied:
+                    await self._set_loop_state(True, result.frame, result.lon, result.lat)
                     log.info("Finished image.")
                 else:
                     log.info("Could not apply offsets.")
-                    self._set_loop_state(False)
+                    await self._set_loop_state(False)
         except ValueError as e:
             log.info("Could not apply offsets: %s", e)
-            self._set_loop_state(False)
+            await self._set_loop_state(False)
 
         # return image, in case we added important data
         return image