pyobs-core 2.0.0.dev20__tar.gz → 2.0.0.dev23__tar.gz

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/PKG-INFO

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

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/pyobs/comm/comm.py

@@ -445,6 +445,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.dev20 → pyobs_core-2.0.0.dev23}/pyobs/comm/xmpp/xmppcomm.py

@@ -143,6 +143,7 @@ class XmppComm(Comm):
         self._loop = asyncio.get_event_loop()
         self._safe_send_attempts = 5
         self._safe_send_wait = 1
+        self._safe_send_timeout = 15.0
 
         # build jid
         if jid:
@@ -799,14 +800,21 @@ class XmppComm(Comm):
         iq = None
         for i in range(self._safe_send_attempts):
             try:
-                # execute method and return result
-                return await method(*args, **kwargs)
+                # execute method and return result, but never wait longer than our own
+                # timeout -- some XMPP servers/slixmpp's own IQ timeout can fail to fire,
+                # which would otherwise hang the caller (and, if called from open(), the
+                # whole module) indefinitely
+                return await asyncio.wait_for(method(*args, **kwargs), timeout=self._safe_send_timeout)
 
             except slixmpp.exceptions.IqTimeout as timeout:
                 # timeout occurred, try again after some wait
                 iq = timeout.iq
                 await asyncio.sleep(self._safe_send_wait)
 
+            except TimeoutError:
+                # our own timeout fired instead of slixmpp's, try again after some wait
+                await asyncio.sleep(self._safe_send_wait)
+
         # never should reach this
         raise slixmpp.exceptions.IqTimeout(iq)
 

pyobs_core-2.0.0.dev23/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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.dev20 → pyobs_core-2.0.0.dev23}/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))

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/pyobs/modules/telescope/dummysolartelescope.py

@@ -51,6 +51,17 @@ class DummySolarTelescope(
 
         self.add_background_task(self._solar_follow_task)
 
+    async def open(self) -> None:
+        """Open module."""
+        await _DummyTelescopeBase.open(self)
+
+        # no solar target is being followed yet -- publish the disk centre as a placeholder so
+        # the pubsub nodes exist (real values get set once a move_heliocentric_polar/
+        # move_heliographic_stonyhurst/move_helioprojective call comes in)
+        await self.comm.set_state(IPointingHeliocentricPolar, HeliocentricPolarState(mu=1.0, psi=0.0))
+        await self.comm.set_state(IPointingHeliographicStonyhurst, HeliographicStonyhurstState(lon=0.0, lat=0.0))
+        await self.comm.set_state(IPointingHelioprojective, HelioprojectiveState(theta_x=0.0, theta_y=0.0))
+
     @staticmethod
     def _heliocentric_polar_to_radec(mu: float, psi: float, time: Time) -> tuple[float, float]:
         """Converts Heliocentric Polar (mu, psi) to (ra, dec) in degrees, ICRS. Mirrors
@@ -142,6 +153,7 @@ class DummySolarTelescope(
                         ra, dec = self._helioprojective_to_radec(a, b, now)
                     self._position = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame="icrs")
                     await self.comm.set_state(IPointingRaDec, RaDecState(ra=ra, dec=dec))
+                    await self._publish_altaz()
 
             await asyncio.sleep(self._SOLAR_FOLLOW_INTERVAL_SECONDS)
 

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/pyobs/modules/utils/dummymode.py

@@ -5,7 +5,7 @@ import logging
 from typing import Any
 
 from pyobs.events import ModeChangedEvent
-from pyobs.interfaces import IMode, IMotion, IReady, ModeCapabilities, ModeState, ReadyState
+from pyobs.interfaces import IMode, IMotion, ModeCapabilities, ModeState
 from pyobs.mixins import MotionStatusMixin
 from pyobs.modules import Module
 from pyobs.utils.enums import MotionStatus
@@ -42,7 +42,6 @@ class DummyMode(MotionStatusMixin, Module, IMode, IMotion):
         # subscribe to events
         if isinstance(self, Module) and self._comm:
             await self.comm.register_event(ModeChangedEvent)
-            await self.comm.set_state(IReady, ReadyState(ready=True))
 
         # publish capabilities and initial state
         await self.comm.set_capabilities(IMode, ModeCapabilities(modes=self._mode_options))

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/pyobs/robotic/utils/skyflats/flatfielder.py

@@ -524,7 +524,13 @@ class FlatFielder(Object):
     def _calc_new_exptime(self) -> None:
         """Calculate new exposure time."""
         # calculate factor for new exposure time
-        factor = (self._target_count - self._bias_level) / (self._median - self._bias_level)
+        denom = self._median - self._bias_level
+        if denom <= 0:
+            # median at or below bias level -- signal is indistinguishable from bias,
+            # so aim for the largest allowed increase in exposure time
+            factor = 10.0
+        else:
+            factor = (self._target_count - self._bias_level) / denom
 
         # limit factor to 0.1-10
         factor = min(10.0, max(0.1, factor))

{pyobs_core-2.0.0.dev20 → pyobs_core-2.0.0.dev23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.0.0.dev20"
+version = "2.0.0.dev23"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"