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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-core
-Version: 2.0.0.dev42
+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.dev42 → 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.
 

{pyobs_core-2.0.0.dev42 → 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.dev42 → 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.dev42 → 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.dev42 → 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.dev42 → 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.dev42 → 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.dev42 → 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.dev42 → pyobs_core-2.0.0.dev43}/pyproject.toml

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