pyobs-core 2.0.0.dev53__tar.gz → 2.0.0.dev55__tar.gz

{pyobs_core-2.0.0.dev53 → pyobs_core-2.0.0.dev55}/PKG-INFO

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

{pyobs_core-2.0.0.dev53 → pyobs_core-2.0.0.dev55}/pyobs/application.py

@@ -45,6 +45,17 @@ if os.environ.get("PYOBS_IERS_OFFLINE", "").lower() in ("1", "true", "yes"):
 warnings.filterwarnings("error", category=RuntimeWarning)
 
 
+def _warm_iers_cache() -> None:
+    """Force astropy's IERS-A table to be loaded/downloaded now, synchronously.
+
+    Meant to run inside an executor thread (see Application._main) -- calling this directly
+    on the event loop would defeat the point.
+    """
+    from astropy.utils.iers import IERS_Auto
+
+    IERS_Auto.open()
+
+
 class InfluxLogConfig(TypedDict):
     url: str
     token: str
@@ -311,6 +322,18 @@ class Application:
 
         # everything in a try/except/finally, so that we can shut down gracefully
         try:
+            # prime astropy's IERS earth-orientation cache now, before any module/comm/network
+            # setup below -- left implicit, the first UT1-UTC lookup (e.g. basetelescope.py's
+            # periodic celestial-header task, ~10-15s after startup) triggers astropy's
+            # auto_download synchronously and blocks the event loop for however long that
+            # download takes, at an unpredictable point during normal operation. Doing it here
+            # in an executor keeps the download latency off the loop and confined to startup.
+            # No-op (near-instant) when PYOBS_IERS_OFFLINE disabled auto_download above.
+            try:
+                await asyncio.get_running_loop().run_in_executor(None, _warm_iers_cache)
+            except Exception:
+                log.warning("Could not prime IERS earth-orientation data, continuing anyway.", exc_info=True)
+
             # resolve the module from the factory, if we're in that mode and haven't yet --
             # runs inside the running loop, so the factory can await anything it needs to
             # (e.g. a login dialog's submit signal) before the module/comm connection exists

{pyobs_core-2.0.0.dev53 → pyobs_core-2.0.0.dev55}/pyobs/comm/comm.py

@@ -39,7 +39,8 @@ class Comm:
         self._log_queue: asyncio.Queue[LogEvent] = asyncio.Queue()
         self._logging_task: asyncio.Task[Any] | None = None
         self._event_handlers: dict[type[Event], list[Callable[[Event, str], Coroutine[Any, Any, bool]]]] = {}
-        self._registered_events: set[type[Event]] = set()
+        self._events_sent: set[type[Event]] = set()
+        self._events_subscribed: set[type[Event]] = set()
         self._closing = asyncio.Event()
         self._published_state: set[type[Interface]] = set()
 
@@ -434,10 +435,10 @@ class Comm:
 
         # we also want to register all events derived from the given one
         event_classes = self._get_derived_events(event_class)
-        self._registered_events.update(event_classes)
 
-        # do we have a handler?
+        # do we have a handler? then we subscribe, otherwise we just declare that we send it
         if handler:
+            self._events_subscribed.update(event_classes)
             # loop classes
             for ev in event_classes:
                 # initialize list
@@ -447,6 +448,8 @@ class Comm:
                 if handler not in self._event_handlers[ev]:
                     # add handler
                     self._event_handlers[ev].append(handler)
+        else:
+            self._events_sent.update(event_classes)
 
         # if event is not a local one, we also need to do some XMPP stuff
         if not event_class.local:
@@ -457,8 +460,9 @@ class Comm:
     ) -> 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.
+        Leaves the event type itself registered as *sent* if the module also declared it via a
+        handler-less register_event() call, only stops calling this handler and, once no handler
+        is left for the event, drops it from what's advertised as *subscribed*.
 
         Args:
             event_class: Class of event that was registered.
@@ -470,6 +474,8 @@ class Comm:
             handlers = self._event_handlers.get(ev)
             if handlers is not None and handler in handlers:
                 handlers.remove(handler)
+                if not handlers:
+                    self._events_subscribed.discard(ev)
 
     async def _register_events(
         self, events: list[type[Event]], handler: Callable[[Event, str], Coroutine[Any, Any, bool]] | None = None

{pyobs_core-2.0.0.dev53 → pyobs_core-2.0.0.dev55}/pyobs/comm/xmpp/xmppcomm.py

@@ -37,6 +37,18 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+def _event_role(ev_cls: type[Event], events_sent: set[type[Event]], events_subscribed: set[type[Event]]) -> str:
+    """Space-separated role(s) ("send", "subscribe", or both) for an event class, for the
+    disco#info `role` attribute -- lets consumers with no access to the pyobs.events catalog
+    (e.g. pyobs-web-client) tell producers from consumers instead of guessing from the union."""
+    roles = []
+    if ev_cls in events_sent:
+        roles.append("send")
+    if ev_cls in events_subscribed:
+        roles.append("subscribe")
+    return " ".join(roles)
+
+
 def _retry_delay(attempt: int, cap: float = 30.0, base: float = 1.0) -> float:
     """Capped exponential backoff with full jitter.
 
@@ -984,10 +996,16 @@ class XmppComm(Comm):
             for interface in self._module.interfaces:
                 info.xml.append(_interface_schema_to_xml(interface))
 
-        # Append event schemas
-        for ev_cls in sorted(self._registered_events, key=lambda e: e.__name__):
-            if not ev_cls.local:
-                info.xml.append(_event_schema_to_xml(ev_cls))
+        # Append event schemas, tagged with a role attribute so consumers that have no access
+        # to the pyobs.events catalog themselves (e.g. pyobs-web-client) can tell which events
+        # a module actually sends vs. which it only subscribes to receive.
+        registered_events = self._events_sent | self._events_subscribed
+        for ev_cls in sorted(registered_events, key=lambda e: e.__name__):
+            if ev_cls.local:
+                continue
+            event_xml = _event_schema_to_xml(ev_cls)
+            event_xml.attrib["role"] = _event_role(ev_cls, self._events_sent, self._events_subscribed)
+            info.xml.append(event_xml)
 
         return info
 

{pyobs_core-2.0.0.dev53 → pyobs_core-2.0.0.dev55}/pyproject.toml

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