pyobs-core 2.0.0.dev28__tar.gz → 2.0.0.dev30__tar.gz

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/PKG-INFO

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

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/application.py

@@ -224,7 +224,7 @@ class Application:
         try:
             # open module
             log.info("Opening module...")
-            await self._module.open()
+            await self._module.startup()
             log.info("Started successfully.")
 
             # run module

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/comm/comm.py

@@ -530,6 +530,21 @@ class Comm:
     async def _set_presence(self, state: ModuleState, error_string: str = "") -> None:
         pass
 
+    async def mark_ready(self) -> None:
+        """Signal that the module has finished its own startup (reached ModuleState.READY) and is
+        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.
+        """
+        await self._mark_ready()
+
+    async def _mark_ready(self) -> None:
+        pass
+
     def get_client_state(self, module: str) -> tuple[ModuleState, str] | None:
         """Return the last known presence state of a connected module.
 

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/comm/xmpp/xmppclient.py

@@ -34,6 +34,9 @@ class XmppClient(slixmpp.ClientXMPP):
         self._jid_conflict = False
         self._conflict_reason: str | None = None
 
+        # module startup gating -- see send_presence()/mark_ready() below
+        self._module_ready = False
+
         # auto-accept invitations
         self.auto_authorize = True
 
@@ -58,6 +61,33 @@ class XmppClient(slixmpp.ClientXMPP):
         self.add_event_handler("stream_error", self._stream_error)
         self.add_filter("in", self._filter_messages)
 
+    def send_presence(self, *args: Any, **kwargs: Any) -> Any:
+        """Override slixmpp's send_presence to hold back every presence broadcast -- the initial
+        online announcement (session_start) as well as re-broadcasts triggered by capability
+        updates (XmppComm._register_events) or lifecycle state changes (XmppComm._set_presence) --
+        until mark_ready() fires. This keeps the module invisible to peers' online-discovery
+        (_got_online/ModuleOpenedEvent) while it's still starting up, so peers never read
+        capabilities that are still mid-publish. Calls made before mark_ready() are simply dropped;
+        mark_ready() sends its own presence once, which is enough to announce the module (any
+        entity-capabilities hash update from a dropped call in the meantime is still picked up,
+        since update_caps() itself isn't gated).
+        """
+        if not self._module_ready:
+            return None
+        return super().send_presence(*args, **kwargs)
+
+    def mark_ready(self) -> None:
+        """Allow send_presence() to actually transmit from here on -- called either once the owning
+        Module first reaches ModuleState.READY (on the live, already-connected client: announce
+        immediately), or by XmppComm._connect() on a freshly created client for a reconnect after
+        the module was already READY (not connected yet -- session_start() will send presence as
+        soon as it fires, now that gating allows it). No-op if already marked ready."""
+        if self._module_ready:
+            return
+        self._module_ready = True
+        if self._connect_event.is_set():
+            self.send_presence()
+
     def reconnect(self, wait: int | float = 2.0, reason: str = "Reconnecting") -> Any:
         """Disconnect only, instead of slixmpp's default reconnect-in-place.
 

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/comm/xmpp/xmppcomm.py

@@ -170,6 +170,12 @@ class XmppComm(Comm):
         self._xmpp: XmppClient | None = None
         self._rpc: RPC | None = None
 
+        # module readiness (see mark_ready()) -- lives here rather than solely on XmppClient
+        # because _connect() replaces self._xmpp with a brand-new instance on every reconnect,
+        # and a reconnect after the module is already READY must announce presence immediately
+        # rather than re-gating it
+        self._module_ready = False
+
         # pubsub for states
         self._pubsub_service = f"pubsub.{self._domain}"
         self._state_node_handlers: dict[str, tuple[type[Interface], list[Callable[[Any], None]]]] = {}
@@ -213,6 +219,18 @@ class XmppComm(Comm):
         # create client
         self._xmpp = XmppClient(self._jid, self._password)
 
+        # presence gating (see mark_ready()) only applies to a comm with an actual Module
+        # attached that hasn't finished starting yet -- a module-less XmppComm (a GUI, an
+        # admin tool, a bare observer in tests) has no such lifecycle and must announce
+        # itself immediately as before, or peers relying on presence-based discovery would
+        # never see it. Likewise, if the module already reached READY on a previous
+        # connection, tell the new client right away -- it isn't connected yet, so this
+        # doesn't send anything itself, but it means session_start() will announce presence
+        # immediately once (re)connected instead of holding it back as if this were the
+        # initial startup.
+        if self._module_ready or not self.has_module:
+            self._xmpp.mark_ready()
+
         # self._xmpp = slixmpp.ClientXMPP(self._jid, password)
         # Register directly with an XML mask rather than via pubsub_publish.
         # slixmpp's StanzaPath matcher requires plugins to be lazily loaded
@@ -957,6 +975,14 @@ class XmppComm(Comm):
             CLOSED → handled by normal disconnect (unavailable)
         error_string rides as <status> text when state is ERROR.
         """
+        # publishing any lifecycle state at all is itself a readiness signal -- covers direct
+        # set_presence() callers that don't go through Module.set_state() (see mark_ready()).
+        # Idempotent: unlocks send_presence() once, then this call's own send below goes through.
+        # Goes through self._mark_ready() (not just self.client.mark_ready()) so self._module_ready
+        # is set too -- otherwise a later reconnect (_connect() creates a brand-new XmppClient)
+        # would re-gate presence on the new client despite this module already being announced.
+        await self._mark_ready()
+
         _show_map: dict[ModuleState, str | None] = {
             ModuleState.READY: None,
             ModuleState.ERROR: "dnd",
@@ -966,6 +992,12 @@ class XmppComm(Comm):
         status = error_string if state == ModuleState.ERROR and error_string else None
         self.client.send_presence(pshow=show, pstatus=status)
 
+    async def _mark_ready(self) -> None:
+        """See Comm.mark_ready(). Remembers readiness on self (survives client recreation on
+        reconnect, see _connect()) and lets the live client announce presence now."""
+        self._module_ready = True
+        self.client.mark_ready()
+
     async def _subscribe_presence(self, module: str, callback: Callable[[ModuleState, str], None]) -> None:
         self._presence_callbacks.setdefault(module, []).append(callback)
         result = self._get_client_state(module)

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/mixins/fitsnamespace.py

@@ -17,7 +17,7 @@ class FitsNamespaceMixin:
         self.__namespaces = {} if fits_namespaces is None else fits_namespaces
 
     def _filter_fits_namespace(
-        self, hdr: dict[str, FitsHeaderEntry], sender: str, namespaces: list[str] | None = None
+        self, hdr: dict[str, FitsHeaderEntry], sender: str, namespaces: list[str] | None = None, **kwargs: Any
     ) -> dict[str, FitsHeaderEntry]:
         """Filter FITS header keywords by given namespaces. If no namespaces are given, let all through. Always
         let keywords with this module's name as namespace pass.

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/mixins/weatheraware.py

@@ -24,6 +24,7 @@ class WeatherAwareMixin:
         self.__last_park_attempt: float | None = None
         self.__weatheraware_is_error_state = False
         self.__weatheraware_lock = asyncio.Lock()
+        self.__weather_check_failures = 0
         this = self
         if isinstance(self, Module):
             if weather is not None:
@@ -122,10 +123,16 @@ class WeatherAwareMixin:
                         async with module.proxy(this.__weather, IWeather) as proxy:
                             weather_state = await proxy.wait_for_state(IWeather, timeout=5.0)
                             this.__is_weather_good = weather_state.good if weather_state is not None else False
+                        this.__weather_check_failures = 0
 
                     except Exception:
-                        # could either not connect or weather is not good
-                        this.__is_weather_good = False
+                        # could not reach the weather module. This can be a real outage, but
+                        # right after startup it's usually just that presence/roster hasn't
+                        # settled yet, so don't jump to "bad weather" (and park) on the very
+                        # first hiccup -- only once it persists across a few checks.
+                        this.__weather_check_failures += 1
+                        if this.__weather_check_failures >= 3:
+                            this.__is_weather_good = False
 
                 # if not good, park now
                 if this.__is_weather_good is False:

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/modules/module.py

@@ -148,8 +148,9 @@ class Module(Object, IModule, IConfig):
         self._device_name = self.comm.name
         self._label = label if label is not None else self._device_name
 
-        # state
-        self._state = ModuleState.READY
+        # state -- starts STARTING, moved to READY once Application finishes the full open() chain
+        # (see Module.execute()'s guard and Application._main)
+        self._state = ModuleState.STARTING
         self._error_string = ""
 
         # own?
@@ -175,6 +176,12 @@ class Module(Object, IModule, IConfig):
     # per-type logging contract a module author gets to opt out of.
     _UNSUPPRESSIBLE: tuple[type[exc.PyobsError], ...] = (exc.ModuleError, exc.UnclassifiedError)
 
+    # methods still callable while the module is ModuleState.STARTING -- introspection/recovery
+    # only, nothing that touches a device that may not be initialized yet. get_version/get_label
+    # are deliberately not listed: they aren't declared on IModule, so they never appear in
+    # self._methods and can't be called via execute() at all, in any state.
+    _STARTING_WHITELIST: tuple[str, ...] = ("get_permitted_methods", "reset_error")
+
     def _disable_exception_logging(self, *exceptions: type[exc.PyobsError]) -> None:
         """Declare that the given PyobsError types (and their subclasses) fire often enough that even the
         default quiet INFO line is too much, and should not be logged locally at all -- the caller already
@@ -320,6 +327,25 @@ class Module(Object, IModule, IConfig):
                 ConfigCapabilities(caps=self._config_caps),
             )
 
+    async def startup(self) -> None:
+        """Open the module and mark it ready for RPC dispatch.
+
+        Runs the full open() override chain (base Module setup plus every subclass's own
+        setup) and only then transitions ModuleState.STARTING -> READY, so Module.execute()
+        starts accepting non-whitelisted calls exactly once startup has actually finished.
+        Every caller that opens a module standalone (Application, MultiModule) should call
+        this instead of open() directly -- otherwise the module stays in STARTING forever.
+        Callers that need finer-grained control (e.g. tests exercising STARTING behavior
+        directly) can call open() and set_state() separately instead.
+
+        Named startup() rather than start() because start() is already IStartStop's abstract
+        RPC method -- a plain start() here would be silently shadowed by any module
+        implementing that interface (guiding, mastermind, scheduler, weather, kiosk, ...),
+        which would then never leave STARTING under Application/MultiModule.
+        """
+        await self.open()
+        await self.set_state(ModuleState.READY)
+
     async def close(self) -> None:
         """Close module."""
         await Object.close(self)
@@ -539,6 +565,10 @@ class Module(Object, IModule, IConfig):
             KeyError: If method does not exist.
         """
 
+        # is module still starting up?
+        if self._state == ModuleState.STARTING and method not in self._STARTING_WHITELIST:
+            raise exc.ModuleStartingError("Module is still starting up, please try again shortly.")
+
         # is module in error state?
         if self._state == ModuleState.ERROR:
             # if called method is not from IModule, raise error
@@ -771,6 +801,11 @@ class Module(Object, IModule, IConfig):
         if self._comm is not None:
             await self._comm.set_presence(state, error_string if error_string is not None else self._error_string)
 
+            # first time reaching READY, tell the transport it may now announce this module to
+            # peers -- e.g. XmppComm delays its initial XMPP presence until here, see mark_ready()
+            if state == ModuleState.READY:
+                await self._comm.mark_ready()
+
     async def get_state(self, **kwargs: Any) -> ModuleState:  # type: ignore[override]
         """Returns current state of module."""
         return self._state
@@ -917,7 +952,7 @@ class MultiModule(Module):
 
         _module_name_var.set(name)
         try:
-            await mod.open()
+            await mod.startup()
             await mod.main()
         except asyncio.CancelledError:
             pass

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/utils/enums.py

@@ -14,12 +14,14 @@ class ModuleState(StrEnum):
 
     Attributes:
         CLOSED: Module is closed.
+        STARTING: Module is starting up and not yet ready to accept commands.
         READY: Module is ready.
         ERROR: Module has an error.
         LOCAL: Module is in local mode and cannot be used remotely.
     """
 
     CLOSED = "closed"
+    STARTING = "starting"
     READY = "ready"
     ERROR = "error"
     LOCAL = "local"

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyobs/utils/exceptions.py

@@ -122,6 +122,15 @@ class DeviceBusyError(PyobsError):
     pass
 
 
+class ModuleStartingError(PyobsError):
+    """The module hasn't finished its own startup yet (still inside `open()`, e.g. connecting to
+    hardware) and isn't safe to command -- distinct from DeviceBusyError, which means the module is
+    fully up but its device is occupied with another operation. Back off and retry once the module
+    reports ModuleState.READY, rather than treating this as a domain failure."""
+
+    pass
+
+
 class NotSupportedError(PyobsError):
     """This module doesn't support the requested operation at all -- a capability the module only
     optionally implements (e.g. an alt/az-only telescope asked to move_radec) isn't available,

{pyobs_core-2.0.0.dev28 → pyobs_core-2.0.0.dev30}/pyproject.toml

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