pyobs-core 2.0.0.dev21__tar.gz → 2.0.0.dev24__tar.gz

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-core
-Version: 2.0.0.dev21
+Version: 2.0.0.dev24
 Summary: robotic telescope software
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/comm/comm.py

@@ -133,16 +133,14 @@ class Comm:
             except IndexError:
                 return None
 
-            # collect capabilities (fixed at proxy construction time)
-            capabilities: dict[type[Interface], Any] = {}
+            # create new proxy
+            proxy = Proxy(self, client, interfaces)
+
+            # fetch capabilities in the background, so a peer that isn't fully up yet doesn't block
+            # proxy construction -- Proxy.wait_for_capabilities() can be used to wait for the result
             for interface in interfaces:
                 if interface.capabilities is not None:
-                    cap = await self._get_capabilities(client, interface)
-                    if cap is not None:
-                        capabilities[interface] = cap
-
-            # create new proxy
-            proxy = Proxy(self, client, interfaces, capabilities)
+                    asyncio.create_task(self._fetch_and_update_capabilities(client, interface, proxy))
 
             # subscribe to state
             for interface in interfaces:
@@ -151,9 +149,14 @@ class Comm:
 
             self._proxies[client] = proxy
 
-        # return proxy
         return self._proxies[client]
 
+    async def _fetch_and_update_capabilities(self, client: str, interface: type[Interface], proxy: Proxy) -> None:
+        """Fetch capabilities for a single interface and push them into the given proxy once available."""
+        cap = await self._get_capabilities(client, interface)
+        if cap is not None:
+            proxy.update_capabilities(interface, cap)
+
     async def _resolve_proxy(
         self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
     ) -> Any | ProxyType:
@@ -445,6 +448,25 @@ class Comm:
         if not event_class.local:
             await self._register_events(event_classes, handler)
 
+    async def unregister_event(
+        self, event_class: type[Event], handler: Callable[[Event, str], Coroutine[Any, Any, bool]]
+    ) -> None:
+        """Remove a handler previously added via register_event().
+
+        Leaves the event type itself registered (other handlers may still be interested in it,
+        and the module may still want to advertise/receive it), only stops calling this handler.
+
+        Args:
+            event_class: Class of event that was registered.
+            handler: The exact handler that was passed to register_event().
+        """
+
+        # same derived-events expansion as register_event(), so this mirrors exactly what was added
+        for ev in self._get_derived_events(event_class):
+            handlers = self._event_handlers.get(ev)
+            if handlers is not None and handler in handlers:
+                handlers.remove(handler)
+
     async def _register_events(
         self, events: list[type[Event]], handler: Callable[[Event, str], Coroutine[Any, Any, bool]] | None = None
     ) -> None:

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/comm/proxy.py

@@ -62,6 +62,7 @@ class Proxy:
         # store state and capabilities
         self._state: dict[type[Interface], Any] = {}
         self._capabilities: dict[type[Interface], Any] = capabilities if capabilities is not None else {}
+        self._capabilities_events: dict[type[Interface], asyncio.Event] = {}
 
     @property
     def name(self) -> str:
@@ -175,8 +176,18 @@ class Proxy:
         """Latest known state for the given interface, or None if nothing has arrived yet."""
         return self._state.get(interface)
 
+    def update_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
+        """Called by Comm once capabilities for an interface arrive.
+
+        Not intended to be called directly by module code.
+        """
+        self._capabilities[interface] = capabilities
+        event = self._capabilities_events.get(interface)
+        if event is not None:
+            event.set()
+
     def get_capabilities(self, interface: type[Interface]) -> Any | None:
-        """Capabilities for the given interface, populated once at Proxy construction."""
+        """Capabilities for the given interface, or None if not (yet) fetched."""
         return self._capabilities.get(interface)
 
     async def wait_for_state(
@@ -203,6 +214,23 @@ class Proxy:
 
         return self._state.get(interface)
 
+    async def wait_for_capabilities(
+        self,
+        interface: type[Interface],
+        timeout: float = 10.0,
+    ) -> Any | None:
+        """Return capabilities immediately if available, otherwise wait for the background fetch to complete."""
+        if self._capabilities.get(interface) is not None:
+            return self._capabilities[interface]
+
+        event = self._capabilities_events.setdefault(interface, asyncio.Event())
+        try:
+            await asyncio.wait_for(event.wait(), timeout=timeout)
+        except TimeoutError:
+            pass
+
+        return self._capabilities.get(interface)
+
 
 class _ProxyContext(Generic[ProxyType]):
     """Returned by Comm.proxy() / Object.proxy() / Comm.safe_proxy(). Must be used as:

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/comm/xmpp/xmppclient.py

@@ -48,7 +48,7 @@ class XmppClient(slixmpp.ClientXMPP):
         self.register_plugin("xep_0199")  # XMPP Ping
 
         # enable keep alive pings
-        self["xep_0199"].enable_keepalive()
+        self.plugin["xep_0199"].enable_keepalive()
 
         # handle session_start and message events
         self.add_event_handler("session_start", self.session_start)

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/comm/xmpp/xmppcomm.py

@@ -909,20 +909,34 @@ class XmppComm(Comm):
         return self._capabilities.get(interface)
 
     async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
-        """Fetch and deserialize capabilities for a remote module's interface."""
+        """Fetch and deserialize capabilities for a remote module's interface.
+
+        Retries a few times, since this may run right as the peer is still starting up and hasn't
+        published its capabilities yet.
+        """
         if interface.capabilities is None:
             return None
-        # Use full JID (with resource) if we know it — bare JID may not route correctly
-        full_jid = next(
-            (jid for jid in self._online_clients if jid.startswith(f"{module}@")),
-            f"{module}@{self._domain}",
-        )
-        jid = full_jid
         ns = f"urn:pyobs:capabilities:{interface.__name__}:{interface.version}"
-        try:
-            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)
+
+        result = None
+        last_error: BaseException | None = None
+        for attempt in range(3):
+            # Use full JID (with resource) if we know it — bare JID may not route correctly
+            full_jid = next(
+                (jid for jid in self._online_clients if jid.startswith(f"{module}@")),
+                f"{module}@{self._domain}",
+            )
+            try:
+                result = await asyncio.wait_for(
+                    self.client.plugin["xep_0030"].get_info(jid=JID(full_jid)), timeout=10.0
+                )
+                break
+            except (TimeoutError, Exception) as e:
+                last_error = e
+                if attempt < 2:
+                    await asyncio.sleep(2)
+        else:
+            log.warning("Failed to get capabilities for %s from %s: %s", interface.__name__, module, last_error)
             return None
         log.debug("get_capabilities disco result XML: %s", ET.tostring(result.xml).decode()[:500])
         # result.xml is the <iq> — the <query> is its child, capabilities are grandchildren

pyobs_core-2.0.0.dev24/pyobs/interfaces/IDataSequence.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.time import Time
+from .IAbortable import IAbortable
+
+
+@dataclass
+class DataSequenceState:
+    count_total: int  # 0 when idle / no sequence running
+    count_left: int
+    time: Time = field(default_factory=Time.now)
+
+
+class IDataSequence(IAbortable, metaclass=ABCMeta):
+    """The module can grab a counted sequence of data (images, spectra, ...)."""
+
+    __module__ = "pyobs.interfaces"
+
+    state = DataSequenceState
+
+    @abstractmethod
+    async def grab_sequence(self, count: int, broadcast: bool = True, **kwargs: Any) -> None:
+        """Start a sequence of `count` grabs. Returns immediately; progress is available via
+        the pushed DataSequenceState.
+
+        Args:
+            count: Number of grabs to take.
+            broadcast: Broadcast existence of each grab.
+
+        Raises:
+            GrabImageError: If the device is already busy (exposing or already running a
+                sequence).
+        """
+        ...
+
+    @abstractmethod
+    async def abort_sequence(self, **kwargs: Any) -> None:
+        """Stop the sequence after the current grab. The grab currently in progress, if any,
+        finishes normally; no further grabs in the sequence are started.
+
+        This is the graceful counterpart to IAbortable.abort(), which remains the hard-stop
+        path: it cancels the running grab immediately *and* the remaining sequence count.
+        """
+        ...
+
+
+__all__ = ["IDataSequence", "DataSequenceState"]

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/interfaces/__init__.py

@@ -23,6 +23,7 @@ from .ICamera import ICamera
 from .IConfig import ConfigCapabilities, ConfigScalar, ConfigValue, IConfig
 from .ICooling import CoolingState, ICooling
 from .IData import IData
+from .IDataSequence import DataSequenceState, IDataSequence
 from .IDome import IDome
 from .IExposure import ExposureState, IExposure
 from .IExposureTime import ExposureTimeState, IExposureTime
@@ -94,6 +95,8 @@ __all__ = [
     "ConfigValue",
     "ICooling",
     "CoolingState",
+    "IDataSequence",
+    "DataSequenceState",
     "IDome",
     "IExposure",
     "ExposureState",

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/mixins/motionstatus.py

@@ -4,7 +4,7 @@ import logging
 from typing import Any
 
 from pyobs.events import MotionStatusChangedEvent
-from pyobs.interfaces import IMotion, MotionState
+from pyobs.interfaces import IMotion, IReady, MotionState, ReadyState
 from pyobs.modules import Module
 from pyobs.utils.enums import MotionStatus
 
@@ -31,6 +31,7 @@ class MotionStatusMixin:
         if isinstance(self, Module) and self._comm:
             await self.comm.register_event(MotionStatusChangedEvent)
             await self.comm.set_state(IMotion, MotionState(status=self.__motion_status))
+            await self.comm.set_state(IReady, ReadyState(ready=self._is_ready()))
 
     async def _change_motion_status(self, status: MotionStatus, interface: str | None = None) -> None:
         """Change motion status and send event,
@@ -88,6 +89,7 @@ class MotionStatusMixin:
                 MotionStatusChangedEvent(status=this.__motion_status, interfaces=this.__motion_status_single)
             )
             await self.comm.set_state(IMotion, MotionState(status=this.__motion_status))
+            await self.comm.set_state(IReady, ReadyState(ready=self._is_ready()))
 
     def _combine_motion_status(self) -> MotionStatus:
         """Method for combining motion statuses for individual interfaces into the global one. Can be overriden."""
@@ -111,6 +113,16 @@ class MotionStatusMixin:
         # otherwise just take status of first interface
         return self.__motion_status_single[self.__motion_status_interfaces[0]]
 
+    def _is_ready(self) -> bool:
+        """Whether the device is ready, for publishing as `IReady` state. Override for device-specific criteria."""
+        return self.motion_status() not in [
+            MotionStatus.PARKED,
+            MotionStatus.INITIALIZING,
+            MotionStatus.PARKING,
+            MotionStatus.ERROR,
+            MotionStatus.UNKNOWN,
+        ]
+
     def motion_status(self, device: str | None = None) -> MotionStatus:
         """Returns current motion status (synchronous, for internal use).
 

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/camera/basecamera.py

@@ -9,12 +9,14 @@ from typing import Any, NamedTuple
 import numpy as np
 from astropy.io import fits
 
-from pyobs.events import ExposureStatusChangedEvent, NewImageEvent
+from pyobs.events import BadWeatherEvent, Event, ExposureStatusChangedEvent, NewImageEvent
 from pyobs.images import Image
 from pyobs.interfaces import (
+    DataSequenceState,
     ExposureState,
     ExposureTimeState,
     ICamera,
+    IDataSequence,
     IExposure,
     IExposureTime,
     IImageType,
@@ -44,7 +46,7 @@ async def calc_expose_timeout(camera: BaseCamera, *args: Any, **kwargs: Any) ->
     return camera._exposure_time + 30
 
 
-class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageType, metaclass=ABCMeta):
+class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageType, IDataSequence, metaclass=ABCMeta):
     """Base class for all camera modules."""
 
     __module__ = "pyobs.modules.camera"
@@ -102,6 +104,11 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         # multi-threading
         self.expose_abort = asyncio.Event()
 
+        # grab_sequence() state -- count_left > 0 means a sequence is currently running
+        # (also between individual grabs, while _camera_status is briefly IDLE again)
+        self._sequence_count_left = 0
+        self._sequence_task: asyncio.Task[None] | None = None
+
         # register exception
         exc.register_exception(exc.GrabImageError, 3, timespan=600, callback=self._default_remote_error_callback)
 
@@ -113,6 +120,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         if self._comm:
             await self.comm.register_event(NewImageEvent)
             await self.comm.register_event(ExposureStatusChangedEvent)
+            await self.comm.register_event(BadWeatherEvent, self._abort_weather)
 
         # publish initial states
         await self.comm.set_state(IExposureTime, ExposureTimeState(exposure_time=self._exposure_time))
@@ -125,6 +133,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
                 exposure_time_left=0.0,
             ),
         )
+        await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
 
     async def set_exposure_time(self, exposure_time: float, **kwargs: Any) -> None:
         """Set the exposure time in seconds.
@@ -361,6 +370,55 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         # return filename
         return filename
 
+    async def grab_sequence(self, count: int, broadcast: bool = True, **kwargs: Any) -> None:
+        """Start a sequence of `count` images. Returns immediately; progress is available via
+        the pushed DataSequenceState.
+
+        Args:
+            count: Number of images to take.
+            broadcast: Broadcast existence of each image.
+
+        Raises:
+            CameraException: If camera is already busy (exposing or already running a sequence).
+        """
+        if count < 1:
+            raise ValueError("count must be >= 1.")
+
+        # already running a sequence, or mid-exposure outside of one?
+        if self._sequence_count_left > 0 or self._camera_status != ExposureStatus.IDLE:
+            raise CameraException("Cannot start new sequence because camera is not idle.")
+
+        log.info("Starting sequence of %d images...", count)
+        self._sequence_count_left = count
+        await self.comm.set_state(IDataSequence, DataSequenceState(count_total=count, count_left=count))
+        self._sequence_task = asyncio.create_task(self._run_sequence(count, broadcast))
+
+    async def _run_sequence(self, count_total: int, broadcast: bool) -> None:
+        """Runs a sequence of grab_data() calls, started by grab_sequence()."""
+        try:
+            while self._sequence_count_left > 0:
+                try:
+                    await self.grab_data(broadcast=broadcast)
+                except exc.PyObsError:
+                    log.exception("Grab failed during sequence, aborting sequence.")
+                    break
+                self._sequence_count_left -= 1
+                await self.comm.set_state(
+                    IDataSequence, DataSequenceState(count_total=count_total, count_left=self._sequence_count_left)
+                )
+        finally:
+            log.info("Finished sequence.")
+            self._sequence_count_left = 0
+            self._sequence_task = None
+            await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
+
+    async def abort_sequence(self, **kwargs: Any) -> None:
+        """Stop the sequence after the current image. The image currently exposing, if any,
+        finishes normally; no further images in the sequence are started.
+        """
+        log.info("Aborting sequence after current image...")
+        self._sequence_count_left = 0
+
     async def _abort_exposure(self) -> None:
         """Abort the running exposure. Should be implemented by derived class.
 
@@ -379,6 +437,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         # set abort event
         log.info("Aborting current image and sequence...")
         self.expose_abort.set()
+        self._sequence_count_left = 0
 
         # do camera-specific abort
         await self._abort_exposure()
@@ -387,6 +446,11 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         while self._camera_status == ExposureStatus.EXPOSING:
             await asyncio.sleep(0.1)
 
+    async def _abort_weather(self, event: Event, sender: str, **kwargs: Any) -> bool:
+        """Abort on bad weather."""
+        await self.abort()
+        return True
+
     @staticmethod
     def set_biassec_trimsec(hdr: fits.Header, left: int, top: int, width: int, height: int) -> None:
         """Calculates and sets the BIASSEC and TRIMSEC areas.

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/camera/basespectrograph.py

@@ -9,7 +9,7 @@ from typing import Any, NamedTuple
 from astropy.io import fits
 
 from pyobs.events import ExposureStatusChangedEvent, NewSpectrumEvent
-from pyobs.interfaces import ISpectrograph
+from pyobs.interfaces import ExposureState, IExposure, ISpectrograph
 from pyobs.mixins.fitsheader import SpectrumFitsHeaderMixin
 from pyobs.modules import Module, timeout
 from pyobs.utils.enums import ExposureStatus
@@ -60,6 +60,15 @@ class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, metaclass
         if self._comm is None:
             log.warning("No comm module given, will not be able to signal new images!")
 
+    async def open(self) -> None:
+        """Open module."""
+        await Module.open(self)
+
+        # publish initial state
+        await self.comm.set_state(
+            IExposure, ExposureState(status=self._spectrograph_status, progress=0.0, exposure_time_left=0.0)
+        )
+
     @abstractmethod
     async def _expose(self, abort_event: asyncio.Event) -> fits.HDUList:
         """Actually do the exposure, should be implemented by derived classes.
@@ -192,6 +201,7 @@ class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, metaclass
 
         # set it
         self._spectrograph_status = status
+        await self.comm.set_state(IExposure, ExposureState(status=status, progress=0.0, exposure_time_left=0.0))
 
     async def abort(self, **kwargs: Any) -> None:
         """Aborts the current exposure.

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/camera/pipelinecamera.py

@@ -3,11 +3,11 @@ from typing import Any
 
 from pyobs.events import NewImageEvent
 from pyobs.images import Image
-from pyobs.interfaces import ICamera
+from pyobs.interfaces import ExposureState, ICamera, IExposure
 from pyobs.mixins import ImageFitsHeaderMixin
 from pyobs.mixins.pipeline import PipelineMixin
 from pyobs.modules import Module
-from pyobs.utils.enums import ImageType
+from pyobs.utils.enums import ExposureStatus, ImageType
 from pyobs.utils.exceptions import GrabImageError
 
 log = logging.getLogger(__name__)
@@ -24,6 +24,15 @@ class PipelineCamera(Module, ICamera, ImageFitsHeaderMixin, PipelineMixin):
         PipelineMixin.__init__(self, **kwargs)
         ImageFitsHeaderMixin.__init__(self, **kwargs)
 
+    async def open(self) -> None:
+        """Open module."""
+        await Module.open(self)
+
+        # publish initial state
+        await self.comm.set_state(
+            IExposure, ExposureState(status=ExposureStatus.IDLE, progress=0.0, exposure_time_left=0.0)
+        )
+
     async def grab_data(self, broadcast: bool = True, **kwargs: Any) -> str:
         """Grabs an image and returns reference.
 

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/flatfield/flatfield.py

@@ -11,13 +11,16 @@ from pyobs.interfaces import (
     ICamera,
     IFilters,
     IFlatField,
+    IMotion,
     IReady,
     ITelescope,
+    MotionState,
     ReadyState,
 )
 from pyobs.modules import Module, timeout
 from pyobs.robotic.utils.skyflats import FlatFielder
 from pyobs.utils import exceptions as exc
+from pyobs.utils.enums import MotionStatus
 from pyobs.utils.publisher import CsvPublisher
 
 log = logging.getLogger(__name__)
@@ -121,6 +124,9 @@ class FlatField(Module, IFlatField, IBinning, IFilters):
         if self._filter is not None:
             await self.comm.set_state(IFilters, FilterState(filter=self._filter))
         await self.comm.set_state(IReady, ReadyState(ready=True))
+        # IFilters extends IMotion, but FlatField isn't itself a moving device -- publish a
+        # static state so the pubsub node exists for anything that subscribes to it
+        await self.comm.set_state(IMotion, MotionState(status=MotionStatus.IDLE))
 
     async def close(self) -> None:
         """Close module."""

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/focus/focusmodel.py

@@ -156,7 +156,10 @@ class FocusModel(Module, IFocusModel):
             await self._calc_focus_model()
 
         # publish initial states
-        await self.comm.set_state(IFocusModel, OptimalFocusState(focus=await self._get_optimal_focus()))
+        try:
+            await self.comm.set_state(IFocusModel, OptimalFocusState(focus=await self._get_optimal_focus()))
+        except ValueError as e:
+            log.warning("Could not publish initial focus model state: %s", e)
 
     async def _update(self) -> None:
         # wait a little
@@ -170,7 +173,12 @@ class FocusModel(Module, IFocusModel):
                 continue
 
             # update states
-            await self.comm.set_state(IFocusModel, OptimalFocusState(focus=await self._get_optimal_focus()))
+            try:
+                await self.comm.set_state(IFocusModel, OptimalFocusState(focus=await self._get_optimal_focus()))
+            except ValueError as e:
+                log.warning("Could not update focus model state: %s", e)
+                await asyncio.sleep(self._interval)
+                continue
 
             # get focuser
             if not await self.has_proxy(self._focuser, IFocuser):
@@ -282,7 +290,10 @@ class FocusModel(Module, IFocusModel):
 
                 # get temperatures
                 async with self.proxy(cfg["module"], ITemperatures) as proxy:
-                    temp_state = proxy.get_state(ITemperatures)
+                    try:
+                        temp_state = await proxy.wait_for_state(ITemperatures)
+                    except TimeoutError:
+                        raise ValueError(f"Timeout waiting for temperatures from module {cfg['module']}.")
                     module_temps[cfg["module"]] = (
                         {r.name: r.value for r in temp_state.readings} if temp_state is not None else {}
                     )

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/pointing/autoguiding.py

@@ -41,6 +41,11 @@ class AutoGuiding(BaseGuiding, CameraSettingsMixin):
         # add thread func
         self.add_background_task(self._auto_guiding)
 
+    async def open(self) -> None:
+        """Open module."""
+        await BaseGuiding.open(self)
+        await self.comm.set_state(IExposureTime, ExposureTimeState(exposure_time=self._default_exposure_time))
+
     async def set_exposure_time(self, exposure_time: float, **kwargs: Any) -> None:
         """Set the exposure time in seconds.
 

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/pointing/scienceframeguiding.py

@@ -4,6 +4,7 @@ from typing import Any
 
 from pyobs.events import Event, NewImageEvent
 from pyobs.images import Image
+from pyobs.interfaces import ExposureTimeState, IExposureTime
 
 from ._baseguiding import BaseGuiding
 
@@ -33,6 +34,10 @@ class ScienceFrameAutoGuiding(BaseGuiding):
         log.info("Subscribing to new image events...")
         await self.comm.register_event(NewImageEvent, self.add_image)
 
+        # exposure time is dictated by incoming science frames, not settable -- but IAutoGuiding
+        # requires IExposureTime, so publish a placeholder state for the pubsub node to exist
+        await self.comm.set_state(IExposureTime, ExposureTimeState(exposure_time=0.0))
+
     async def set_exposure_time(self, exposure_time: float, **kwargs: Any) -> None:
         """Set the exposure time for the auto-guider.
 

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/roof/baseroof.py

@@ -4,7 +4,7 @@ import logging
 from abc import ABCMeta
 from typing import Any
 
-from pyobs.interfaces import FitsHeaderEntry, IFitsHeaderBefore, IReady, IRoof, ReadyState
+from pyobs.interfaces import FitsHeaderEntry, IFitsHeaderBefore, IRoof
 from pyobs.mixins import MotionStatusMixin, WeatherAwareMixin
 from pyobs.modules import Module
 from pyobs.utils.enums import MotionStatus
@@ -32,9 +32,6 @@ class BaseRoof(WeatherAwareMixin, MotionStatusMixin, IRoof, IFitsHeaderBefore, M
         await WeatherAwareMixin.open(self)
         await MotionStatusMixin.open(self)
 
-        # publish initial ready state
-        await self.comm.set_state(IReady, ReadyState(ready=self._is_ready()))
-
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
     ) -> dict[str, FitsHeaderEntry]:
@@ -53,15 +50,5 @@ class BaseRoof(WeatherAwareMixin, MotionStatusMixin, IRoof, IFitsHeaderBefore, M
             )
         }
 
-    def _is_ready(self) -> bool:
-        """The roof is ready if it is open (not parked, initializing, parking, error, or unknown)."""
-        return self.motion_status() not in [
-            MotionStatus.PARKED,
-            MotionStatus.INITIALIZING,
-            MotionStatus.PARKING,
-            MotionStatus.ERROR,
-            MotionStatus.UNKNOWN,
-        ]
-
 
 __all__ = ["BaseRoof"]

{pyobs_core-2.0.0.dev21 → pyobs_core-2.0.0.dev24}/pyobs/modules/telescope/_dummytelescopebase.py

@@ -12,6 +12,7 @@ from astropy.coordinates import SkyCoord
 
 from pyobs.events import FilterChangedEvent
 from pyobs.interfaces import (
+    AltAzState,
     FiltersCapabilities,
     FilterState,
     FitsHeaderEntry,
@@ -137,6 +138,14 @@ class _DummyTelescopeBase(
     def _position_radec(self) -> tuple[float, float] | None:
         return float(self._position.ra.degree), float(self._position.dec.degree)
 
+    async def _publish_altaz(self) -> None:
+        """Publish the current position as IPointingAltAz state, derived from RA/Dec and the observer location."""
+        if self._observer is not None:
+            altaz = self.observer.altaz(Time.now(), self._position)
+            await self.comm.set_state(
+                IPointingAltAz, AltAzState(alt=float(altaz.alt.degree), az=float(altaz.az.degree))
+            )
+
     async def _sim_change_status(self, status: MotionStatus) -> None:
         if status != self._sim_status:
             self._sim_status = status
@@ -168,6 +177,7 @@ class _DummyTelescopeBase(
                             dec=float(self._position.dec.degree),
                         ),
                     )
+                    await self._publish_altaz()
                 else:
                     dra = vra / length * self._speed / np.cos(np.radians(self._position.dec.degree)) * u.deg
                     ddec = vdec / length * self._speed * u.deg
@@ -182,6 +192,7 @@ class _DummyTelescopeBase(
                         IPointingRaDec,
                         RaDecState(ra=float(self._position.ra.degree), dec=float(self._position.dec.degree)),
                     )
+                    await self._publish_altaz()
 
                 drift_ra = random.gauss(self._drift_rate[0], max(self._drift_rate[0] / 10.0, 1e-9))
                 drift_dec = random.gauss(self._drift_rate[1], max(self._drift_rate[1] / 10.0, 1e-9))
@@ -224,6 +235,7 @@ class _DummyTelescopeBase(
                 dec=float(self._position.dec.degree),
             ),
         )
+        await self._publish_altaz()
         await self.comm.set_capabilities(ITrackingMode, TrackingModeCapabilities(modes=self._tracking_modes))
         await self.comm.set_capabilities(ITrackingRate, TrackingRateCapabilities(min_update_interval=0.0))
         await self.comm.set_state(ITrackingMode, TrackingModeState(mode=self._tracking_mode))