pyobs-core 2.0.0.dev41__tar.gz → 2.0.0.dev43__tar.gz

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/PKG-INFO

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

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/application.py

@@ -193,7 +193,7 @@ class Application:
         # (module.py), never meant to match a filename -- each child module is already
         # correctly distinguished via execute()/BackgroundTask.
         if not isinstance(self._module, MultiModule):
-            config_stem = Path(self._config).stem
+            config_stem = Path(self._config).stem.lstrip("_")
             if self._module.name != config_stem:
                 log.warning(
                     "Config file stem (%s) does not match module's own name "

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/comm/comm.py

@@ -41,6 +41,7 @@ class Comm:
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
         self._registered_events: set[type[Event]] = set()
         self._closing = asyncio.Event()
+        self._published_state: set[type[Interface]] = set()
 
     @property
     def has_module(self) -> bool:
@@ -479,11 +480,17 @@ class Comm:
             interface: Interface type for the state.
             state: State object to publish.
         """
+        self._published_state.add(interface)
         await self._set_state(interface, state)
 
     async def _set_state(self, interface: type[Interface], state: Any) -> None:
         pass
 
+    def missing_published_state(self, interfaces: list[type[Interface]]) -> list[type[Interface]]:
+        """Return interfaces (from the given list) that declare state via has_own_state() but
+        haven't had set_state() called for them yet."""
+        return [i for i in interfaces if i.has_own_state() and i not in self._published_state]
+
     async def set_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
         """Publish capabilities for this module.
 
@@ -535,10 +542,10 @@ class Comm:
         safe for peers to discover.
 
         Called by Module once it transitions to READY. Transports that announce a module to peers
-        independently of RPC dispatch (e.g. XmppComm's XMPP presence, which drives other modules'
-        peer-discovery reaction) hold that announcement back until this fires, so peers never read
-        capabilities that are still mid-publish. Transports without such an announcement (e.g.
-        LocalComm) don't need to override this.
+        independently of RPC dispatch (e.g. XmppComm's XMPP presence, or LocalComm's direct
+        ModuleOpenedEvent dispatch to already-connected peers) hold that announcement back until
+        this fires, so peers never read capabilities that are still mid-publish. Transports without
+        such an announcement don't need to override this.
         """
         await self._mark_ready()
 

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/comm/local/localcomm.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from pyobs.comm import Comm
 from pyobs.comm.comm import PresenceCallback
-from pyobs.events import Event
+from pyobs.events import Event, ModuleOpenedEvent
 from pyobs.interfaces import Interface
 from pyobs.utils.enums import ModuleState
 
@@ -26,6 +26,7 @@ class LocalComm(Comm):
         self._capabilities: dict[type[Interface], Any] = {}  # interface -> Capabilities object
         self._presence: tuple[ModuleState, str] = (ModuleState.READY, "")
         self._presence_callbacks: dict[str, list[PresenceCallback]] = {}
+        self._ready = False
 
     @property
     def name(self) -> str:
@@ -158,3 +159,15 @@ class LocalComm(Comm):
             callback(*remote._presence)
         except KeyError:
             pass
+
+    async def _mark_ready(self) -> None:
+        """Announce this module to already-connected peers, mirroring XmppComm's presence-based
+        discovery (_got_online sending ModuleOpenedEvent) -- without this, a module that joins the
+        LocalNetwork after a peer has already started is invisible to that peer's ModuleOpenedEvent
+        handlers until the peer restarts (see #677). Guarded so a later re-READY doesn't re-announce."""
+        if self._ready:
+            return
+        self._ready = True
+        for client in self._network.get_clients():
+            if client is not self:
+                client._send_event_to_module(ModuleOpenedEvent(), self._name)

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/comm/proxy.py

@@ -7,6 +7,7 @@ from collections.abc import Coroutine
 from typing import TYPE_CHECKING, Any, Generic, TypeVar, get_type_hints
 
 from pyobs.interfaces import Interface
+from pyobs.utils.time import Time
 
 if TYPE_CHECKING:
     from pyobs.comm import Comm
@@ -172,9 +173,22 @@ class Proxy:
         """Clear all cached state. Called by Comm when the remote module disconnects."""
         self._state.clear()
 
-    def get_state(self, interface: type[Interface]) -> Any | None:
-        """Latest known state for the given interface, or None if nothing has arrived yet."""
-        return self._state.get(interface)
+    def get_state(self, interface: type[Interface], *, max_age: float | None = None) -> Any | None:
+        """Latest known state for the given interface, or None if nothing has arrived yet
+        (or, with max_age given, if the latest known state is older than max_age seconds)."""
+        state = self._state.get(interface)
+        if state is None or max_age is None:
+            return state
+        return state if self._state_age(state) <= max_age else None
+
+    def _state_age(self, state: Any) -> float:
+        """Seconds since `state` (a State dataclass instance) was constructed by its publisher."""
+        t = getattr(state, "time", None)
+        if t is None:
+            raise ValueError(
+                f"{type(state).__name__} has no 'time' field -- max_age is not supported for this interface."
+            )
+        return (Time.now() - t).sec
 
     def update_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
         """Called by Comm once capabilities for an interface arrive.
@@ -194,16 +208,22 @@ class Proxy:
         self,
         interface: type[Interface],
         timeout: float = 10.0,
+        *,
+        max_age: float | None = None,
     ) -> Any:
-        """Return state immediately if available, otherwise wait for the first update.
+        """Return state immediately if available (and fresh enough per max_age), otherwise wait
+        for the next update.
 
         Returns None on timeout rather than raising -- every caller across the codebase already
         does `if state is not None else ...` right after calling this, so that's the contract
         actually being relied on; letting asyncio.wait_for's TimeoutError propagate would just
-        turn "peer hasn't published yet" into an unhandled exception for all of them.
+        turn "peer hasn't published yet" into an unhandled exception for all of them. The same
+        None-on-"not usable yet" contract now also covers "published, but too stale" when max_age
+        is given.
         """
-        if self._state.get(interface) is not None:
-            return self._state[interface]
+        cached = self._state.get(interface)
+        if cached is not None and (max_age is None or self._state_age(cached) <= max_age):
+            return cached
 
         event = asyncio.Event()
 
@@ -220,7 +240,10 @@ class Proxy:
         finally:
             await self._comm.unsubscribe_state(self._client, interface, _notify)
 
-        return self._state.get(interface)
+        result = self._state.get(interface)
+        if max_age is not None and result is not None and self._state_age(result) > max_age:
+            return None
+        return result
 
     async def wait_for_capabilities(
         self,

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/comm/xmpp/xmppcomm.py

@@ -315,6 +315,14 @@ class XmppComm(Comm):
         self._xmpp.enable_direct_tls = self._use_tls
         self._xmpp.enable_plaintext = not self._use_tls
         self._xmpp.plugin["feature_mechanisms"].unencrypted_scram = not self._use_tls  # type: ignore[typeddict-item]
+        # Without this, slixmpp still refuses PLAIN over a non-TLS connection even
+        # with enable_plaintext set above -- it only affects the stream feature
+        # advertisement, not SASL mechanism selection. Matters in practice: this
+        # server's SCRAM implementation fails unencrypted SCRAM auth with "Invalid
+        # channel binding" (confirmed against ejabberd 26.4.0), so without this
+        # flag every non-TLS connection falls through all mechanisms and fails
+        # with "No appropriate login method" rather than falling back to PLAIN.
+        self._xmpp.plugin["feature_mechanisms"].unencrypted_plain = not self._use_tls  # type: ignore[typeddict-item]
         if self._ignore_cert_errors:
             self._xmpp.ssl_context.check_hostname = False
             self._xmpp.ssl_context.verify_mode = ssl.CERT_NONE

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/interfaces/interface.py

@@ -42,7 +42,7 @@ class Interface(metaclass=ABCMeta):
             )
         _REGISTRY[cls.__name__] = cls
 
-    def get_state(self, interface: "type[Interface]") -> Any | None:
+    def get_state(self, interface: "type[Interface]", *, max_age: float | None = None) -> Any | None:
         """Return the last received state for the given interface, or None."""
         return None
 
@@ -50,7 +50,9 @@ class Interface(metaclass=ABCMeta):
         """Return the capabilities for the given interface, or None."""
         return None
 
-    async def wait_for_state(self, interface: "type[Interface]", timeout: float = 10.0) -> Any | None:
+    async def wait_for_state(
+        self, interface: "type[Interface]", timeout: float = 10.0, *, max_age: float | None = None
+    ) -> Any | None:
         """Return state immediately if available, otherwise wait for the first update."""
         return None
 

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/mixins/weatheraware.py

@@ -18,8 +18,9 @@ class WeatherAwareMixin:
 
     __module__ = "pyobs.mixins"
 
-    def __init__(self, weather: str | IWeather | None = None, **kwargs: Any):
+    def __init__(self, weather: str | IWeather | None = None, weather_max_age: float = 120.0, **kwargs: Any):
         self.__weather = weather
+        self.__weather_max_age = weather_max_age
         self.__is_weather_good: bool | None = None
         self.__last_park_attempt: float | None = None
         self.__weatheraware_is_error_state = False
@@ -121,7 +122,9 @@ class WeatherAwareMixin:
                     try:
                         # get good status
                         async with module.proxy(this.__weather, IWeather) as proxy:
-                            weather_state = await proxy.wait_for_state(IWeather, timeout=5.0)
+                            weather_state = await proxy.wait_for_state(
+                                IWeather, timeout=5.0, max_age=this.__weather_max_age
+                            )
                             this.__is_weather_good = weather_state.good if weather_state is not None else False
                         this.__weather_check_failures = 0
 

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/camera/basecamera.py

@@ -464,8 +464,11 @@ class BaseCamera(
             await asyncio.sleep(0.1)
 
     async def _abort_weather(self, event: Event, sender: str, **kwargs: Any) -> bool:
-        """Abort on bad weather."""
-        await self.abort()
+        """Abort on bad weather, unless the shutter is closed (dark/bias) -- those don't
+        expose anything to the weather, and image_type is fixed for a whole sequence, so
+        this also lets an in-progress dark/bias sequence run to completion undisturbed."""
+        if self._image_type not in (ImageType.BIAS, ImageType.DARK):
+            await self.abort()
         return True
 
     @staticmethod

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/camera/dummycamera.py

@@ -153,6 +153,12 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
             ICooling,
             CoolingState(setpoint=self._cooling.set_point, power=self._cooling.power, enabled=self._cooling.enabled),
         )
+        await self.comm.set_state(
+            ITemperatures,
+            TemperaturesState(
+                readings=[SensorReading(name=name, value=value) for name, value in self._cooling.temperatures.items()]
+            ),
+        )
         await self.comm.set_state(IGain, GainState(gain=self._gain, offset=self._gain_offset))
         await self.comm.set_state(IWindow, WindowState(*self._full_frame))
         await self.comm.set_state(IBinning, BinningState(*self._binning))

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/flatfield/flatfield.py

@@ -106,14 +106,6 @@ class FlatField(Module, IFlatField, IBinning, IFilters):
         """Open module"""
         await Module.open(self)
 
-        # check telescope, camera, and filters
-        if (
-            not await self.has_proxy(self._telescope, ITelescope)
-            or not await self.has_proxy(self._camera, ICamera)
-            or not await self.has_proxy(self._filter_wheel, IFilters)
-        ):
-            log.warning("Either telescope, camera or filters do not exist or are not of correct type at the moment.")
-
         # subscribe to events
         if self._comm:
             await self.comm.register_event(BadWeatherEvent, self._abort_weather)

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/flatfield/scheduler.py

@@ -68,14 +68,6 @@ class FlatFieldScheduler(Module, IRunnable):
             count=count,
         )
 
-    async def open(self) -> None:
-        """Open module"""
-        await Module.open(self)
-
-        # check flat field
-        if not await self.has_proxy(self._flatfield, IFlatField):
-            log.warning("Flatfield module does not exist or is not of correct type at the moment.")
-
     @timeout(7200)
     async def run(self, **kwargs: Any) -> None:
         """Perform flat-fielding

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/focus/focusseries.py

@@ -95,10 +95,6 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
         await self.comm.register_event(FocusFoundEvent)
         await self.comm.register_event(BadWeatherEvent, self._on_bad_weather)
 
-        # check focuser and camera
-        if not await self.has_proxy(self._focuser, IFocuser) or not await self.has_proxy(self._camera, IData):
-            log.warning("Either camera or focuser do not exist or are not of correct type at the moment.")
-
         # publish initial states
         await self.comm.set_state(IAutoFocus, AutoFocusState())
         await self.comm.set_state(IRunning, RunningState(running=False))

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/module.py

@@ -344,6 +344,17 @@ class Module(Object, IModule, IConfig):
         which would then never leave STARTING under Application/MultiModule.
         """
         await self.open()
+
+        # warn if any stateful interface hasn't published state yet
+        if self._comm is not None:
+            missing = self._comm.missing_published_state(self._interfaces)
+            for iface in missing:
+                log.warning(
+                    "Module %s implements %s which declares state, but no state has been published for it yet.",
+                    self.name,
+                    iface.__name__,
+                )
+
         await self.set_state(ModuleState.READY)
 
     async def close(self) -> None:

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/pointing/_base.py

@@ -57,17 +57,5 @@ class BasePointing(Module, PipelineMixin, metaclass=ABCMeta):
                 exc.RemoteError, 3, timespan=600, module=telescope, callback=self._default_remote_error_callback
             )
 
-    async def open(self) -> None:
-        """Open module."""
-        await Module.open(self)
-
-        # check telescope
-        if not await self.has_proxy(self._telescope, ITelescope):
-            log.warning("Given telescope does not exist or is not of correct type at the moment.")
-
-        # check camera
-        if not await self.has_proxy(self._camera, ICamera):
-            log.warning("Given camera does not exist or is not of correct type at the moment.")
-
 
 __all__ = ["BasePointing"]

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/pointing/acquisition.py

@@ -99,12 +99,6 @@ class Acquisition(BasePointing, CameraSettingsMixin, IAcquisition):
         """Open module"""
         await Module.open(self)
 
-        # check telescope and camera
-        if not await self.has_proxy(self._telescope, ITelescope):
-            log.warning("Telescope does not exist or is not of correct type at the moment.")
-        if not await self.has_proxy(self._camera, ICamera):
-            log.warning("Camera does not exist or is not of correct type at the moment.")
-
         # publish initial states
         await self.comm.set_state(IAcquisition, AcquisitionState())
         await self.comm.set_state(IRunning, RunningState(running=False))

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyobs/modules/weather/weather.py

@@ -93,6 +93,7 @@ class Weather(Module, IWeather, IFitsHeaderBefore):
             await self.comm.register_event(GoodWeatherEvent)
 
         await self.comm.set_state(IRunning, RunningState(running=self._active))
+        await self._publish_state()
 
     async def start(self, **kwargs: Any) -> None:
         """Starts a service."""
@@ -150,6 +151,9 @@ class Weather(Module, IWeather, IFitsHeaderBefore):
                 await self.comm.send_event(BadWeatherEvent())
 
         # publish state
+        await self._publish_state()
+
+    async def _publish_state(self) -> None:
         is_good = True if not self._active else self._weather.is_good
         await self.comm.set_state(IWeather, WeatherState(good=is_good, readings=self._get_readings()))
 

{pyobs_core-2.0.0.dev41 → pyobs_core-2.0.0.dev43}/pyproject.toml

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