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

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

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

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

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