pyobs-core 2.0.0.dev76__tar.gz → 2.0.0.dev78__tar.gz

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/PKG-INFO

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

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/application.py

@@ -16,6 +16,7 @@ from pyobs.modules import Module, MultiModule
 from pyobs.object import get_class_from_string, get_object
 from pyobs.utils.config import pre_process_yaml
 from pyobs.utils.logging.context import ModuleNameFilter
+from pyobs.utils.versions import loaded_pyobs_packages
 
 # just init logger with something here, will be overwritten in __init__
 log = logging.getLogger(__name__)
@@ -375,6 +376,18 @@ class Application:
 
             # open module
             log.info("Opening module...")
+
+            # record the loaded pyobs package versions for comm-less consumers (e.g. web-admin
+            # reading the log/journal); both construction paths have finished importing everything
+            # by this point. Guarded like the IERS priming above: metadata scanning can raise on
+            # any installed distribution with broken dist-info, and that's not worth aborting
+            # startup over.
+            try:
+                packages = loaded_pyobs_packages()
+                log.info("Loaded pyobs packages: %s", ", ".join(f"{k}={v}" for k, v in packages.items()))
+            except Exception:
+                log.warning("Could not determine loaded pyobs package versions, continuing anyway.", exc_info=True)
+
             await self._module.startup()
             log.info("Started successfully.")
 

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/comm/comm.py

@@ -470,18 +470,28 @@ class Comm:
         """
 
         # same derived-events expansion as register_event(), so this mirrors exactly what was added
+        unsubscribed: list[type[Event]] = []
         for ev in self._get_derived_events(event_class):
             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)
+                    unsubscribed.append(ev)
+
+        # only event classes that just lost their last handler need the comm layer to actually
+        # tear anything down (e.g. XmppComm unsubscribing from peers' event nodes)
+        if unsubscribed and not event_class.local:
+            await self._unregister_events(unsubscribed)
 
     async def _register_events(
         self, events: list[type[Event]], handler: Callable[[Event, str], Coroutine[Any, Any, bool]] | None = None
     ) -> None:
         pass
 
+    async def _unregister_events(self, events: list[type[Event]]) -> None:
+        pass
+
     async def set_state(self, interface: type[Interface], state: Any) -> None:
         """Publish state for this module.
 

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/comm/xmpp/xmppclient.py

@@ -60,7 +60,6 @@ class XmppClient(slixmpp.ClientXMPP):
         self.register_plugin("xep_0045")  # Multi-User Chat
         self.register_plugin("xep_0060")  # PubSub
         self.register_plugin("xep_0115")  # Entity Capabilities
-        self.register_plugin("xep_0163")  # Personal Eventing Protocol
         self.register_plugin("xep_0199")  # XMPP Ping
 
         # enable keep alive pings

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/comm/xmpp/xmppcomm.py

@@ -190,6 +190,7 @@ class XmppComm(Comm):
         self._online_clients: list[str] = []
         self._interface_cache: dict[str, asyncio.Future[list[type[Interface]]]] = {}
         self._interface_features: dict[str, list[str]] = {}
+        self._peer_sent_events: dict[str, set[tuple[str, int]]] = {}
         self._warned_version_mismatches: set[tuple[str, str]] = set()
         self._user = user
         self._password = password
@@ -240,6 +241,11 @@ class XmppComm(Comm):
         self._pubsub_service = f"pubsub.{self._domain}"
         self._state_node_handlers: dict[str, tuple[type[Interface], list[Callable[[Any], None]]]] = {}
         self._client_states: dict[str, tuple[ModuleState, str]] = {}  # jid -> (state, error_string)
+
+        # pubsub for events -- desired (peer module name, event class) subscriptions. A key's
+        # presence drives _subscribe_event_with_retry's retry loop; removing it (unregister, or
+        # never re-added on a fresh connect) is what stops a still-retrying subscribe.
+        self._event_subscriptions: set[tuple[str, type[Event]]] = set()
         self._capabilities: dict[type, Any] = {}  # interface → Capabilities instance
         self._own_states: dict[type, Any] = {}  # interface → last published state for this module
         self._presence_callbacks: dict[str, list[Callable[[ModuleState, str], None]]] = {}
@@ -500,6 +506,14 @@ class XmppComm(Comm):
         # cache raw features for this JID, so a later version-mismatch can be diagnosed
         self._interface_features[jid] = features
 
+        # cache which event types this peer actually publishes (role="send" in the rich <event>
+        # schema elements from _get_disco_info) -- distinct from the plain urn:pyobs:event:
+        # feature list above, which covers subscribe-only registrations too and can't tell a
+        # publisher apart from a mere consumer. Used to gate event-node subscriptions so we don't
+        # retry forever against peers that will never publish to that node (see _got_online,
+        # _register_events).
+        self._peer_sent_events[jid] = self._parse_peer_sent_events(info)
+
         # keep only names whose remote-published version matches what this client expects --
         # a mismatch is treated the same as the interface not being there at all, rather than
         # silently using the local (possibly incompatible) class
@@ -522,6 +536,36 @@ class XmppComm(Comm):
         # finished
         return interface_names
 
+    @staticmethod
+    def _parse_peer_sent_events(info: Any) -> set[tuple[str, int]]:
+        """Extract (event class name, version) pairs a peer's disco#info marks role="send" for.
+
+        Reads the rich <{urn:pyobs:event:name:version}event role="..."> elements _get_disco_info
+        appends (see _event_role), not the plain urn:pyobs:event: feature list -- that list only
+        says the peer registered the event at all, sent or subscribe-only, and can't tell a
+        publisher apart from a mere consumer.
+        """
+        sent: set[tuple[str, int]] = set()
+        xml = getattr(info, "xml", None)
+        if xml is None:
+            return sent
+        ns_prefix = "urn:pyobs:event:"
+        for elem in xml:
+            tag = elem.tag
+            if not tag.startswith("{") or "}" not in tag:
+                continue
+            ns, _, local = tag[1:].partition("}")
+            if local != "event" or not ns.startswith(ns_prefix):
+                continue
+            if "send" not in elem.get("role", "").split():
+                continue
+            name = elem.get("name")
+            _, _, version_str = ns[len(ns_prefix) :].rpartition(":")
+            if not name or not version_str.isdigit():
+                continue
+            sent.add((name, int(version_str)))
+        return sent
+
     def _diagnose_missing_interface(self, client: str, obj_type: type[Any]) -> str | None:
         """Checks the disco#info features already cached for client for a version of obj_type
         other than the one this client expects, to tell a version mismatch apart from
@@ -665,6 +709,27 @@ class XmppComm(Comm):
         if jid not in self._online_clients:
             self._online_clients.append(jid)
 
+        # subscribe to this peer's event nodes for every event type we currently handle -- a
+        # handler registered before this peer came online never got a chance to subscribe to it
+        # from _register_events, since it wasn't in self._online_clients yet.
+        # Skip local events (e.g. ModuleOpenedEvent/ModuleClosedEvent, registered by every
+        # module via module.py/comm.py) -- they're synthesized locally here and in
+        # _jid_got_offline, never published to a node, so subscribing would retry forever
+        # against something that will never exist. Also skip event classes whose last handler
+        # was already removed -- unregister_event() discards from _events_subscribed but leaves
+        # an empty list in _event_handlers. Also skip event types this peer doesn't actually
+        # publish (per its disco#info role="send" list, cached above by _get_interfaces) --
+        # otherwise every module subscribes to every peer for every event type it handles, e.g. a
+        # camera's BadWeatherEvent handler retry-subscribing to admin:BadWeatherEvent forever,
+        # since that node will never be created.
+        peer_sent_events = self._peer_sent_events.get(jid, set())
+        for ev, handlers in self._event_handlers.items():
+            if ev.local or not handlers:
+                continue
+            if (ev.__name__, ev.version) not in peer_sent_events:
+                continue
+            asyncio.create_task(self._subscribe_event_with_retry(module_name, ev))
+
         # send event
         self._send_event_to_module(ModuleOpenedEvent(), msg["from"].username)
 
@@ -777,11 +842,18 @@ class XmppComm(Comm):
         # set xml and send event
         stanza.xml = ET.fromstring(f'<event xmlns="pyobs:event">{body}</event>')
 
-        # send it
+        # publish to the shared pubsub service, same mechanism as state (see _set_state) --
+        # the node id encodes the publishing module, since notifications from this service
+        # arrive "from" the service itself, not from us (see _event_node/_handle_event).
+        # A module-less XmppComm (GUI, admin tool, observer) has no self._module -- fall back to
+        # the JID's own username, same identity peers would derive from our JID anyway.
+        publisher = self._module.name if self._module is not None else self.client.boundjid.user
+        node = self._event_node(publisher, event.__class__)
         await self._safe_send(
-            self.client.plugin["xep_0163"].publish,
-            stanza,
-            node=f"urn:pyobs:event:{event.__class__.__name__}:{event.version}",
+            self.client.plugin["xep_0060"].publish,
+            self._pubsub_service,
+            node,
+            payload=stanza,
             callback=functools.partial(self._send_event_callback, event=event),
         )
 
@@ -804,18 +876,82 @@ class XmppComm(Comm):
     ) -> None:
         # loop events
         for ev in events:
-            # register event at XMPP
+            # register event at XMPP (disco advertising only -- unrelated to delivery, used by
+            # e.g. pyobs-web-client to distinguish producers from consumers, see _event_role)
             self.client.plugin["xep_0030"].add_feature(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
 
-            # if we have a handler, we're also interested in receiving such events
+            # if we have a handler, subscribe to this event's node on every peer already online
+            # that actually publishes it (see _got_online for why this is gated). A peer coming
+            # online later is covered by _got_online subscribing to every event currently in
+            # self._event_handlers.
             if handler:
-                # add interest
-                self.client.plugin["xep_0163"].add_interest(f"urn:pyobs:event:{ev.__name__}:{ev.version}")
+                for peer_jid in list(self._online_clients):
+                    if (ev.__name__, ev.version) not in self._peer_sent_events.get(peer_jid, set()):
+                        continue
+                    peer_module = peer_jid[: peer_jid.index("@")]
+                    asyncio.create_task(self._subscribe_event_with_retry(peer_module, ev))
 
         # update caps and send presence
         await self._safe_send(self.client.plugin["xep_0115"].update_caps)
         self.client.send_presence()
 
+    async def _unregister_events(self, events: list[type[Event]]) -> None:
+        # unsubscribe goes to self._pubsub_service, not to the peer -- it doesn't depend on the
+        # peer being online, so this has to cover every (peer, ev) we're actually subscribed to,
+        # not just currently-online ones (a peer offline at unregister time would otherwise keep
+        # its server-side subscription, and we'd go on receiving that event's wire message)
+        for ev in events:
+            for peer_module, key_ev in list(self._event_subscriptions):
+                if key_ev is not ev:
+                    continue
+                self._event_subscriptions.discard((peer_module, ev))
+                node = self._event_node(peer_module, ev)
+                try:
+                    await self._safe_send(self.client.plugin["xep_0060"].unsubscribe, self._pubsub_service, node)
+                except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+                    pass  # already gone server-side
+
+    @staticmethod
+    def _event_node(module: str, event_class: type[Event]) -> str:
+        return f"pyobs:event:{module}:{event_class.__name__}:{event_class.version}"
+
+    @staticmethod
+    def _event_node_module(node: str) -> str | None:
+        """Recover the publishing module's name from an event node id, since notifications from
+        the shared pubsub service arrive "from" the service itself, not from the publisher."""
+        parts = node.split(":")
+        if len(parts) == 5 and parts[0] == "pyobs" and parts[1] == "event":
+            return parts[2]
+        return None
+
+    async def _subscribe_event_with_retry(self, peer_module: str, event_class: type[Event]) -> None:
+        """Subscribe to a peer's event node, retrying until the node exists.
+
+        Mirrors _subscribe_with_retry (state). Runs as a background task; retries indefinitely
+        with capped backoff since the peer may not have published (and thus auto-created the
+        node) yet. Stops early if _unregister_events drops the (peer_module, event_class) key
+        in the meantime.
+        """
+        key = (peer_module, event_class)
+        if key in self._event_subscriptions:
+            return
+        self._event_subscriptions.add(key)
+        node = self._event_node(peer_module, event_class)
+        attempt = 0
+        while key in self._event_subscriptions:
+            try:
+                await self._safe_send(self.client.plugin["xep_0060"].subscribe, self._pubsub_service, node)
+                return
+            except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+                attempt += 1
+                if attempt == 30:
+                    log.warning(
+                        "Still failing to subscribe to event node %s after %d attempts, will keep retrying",
+                        node,
+                        attempt,
+                    )
+                await asyncio.sleep(_retry_delay(attempt))
+
     def _handle_event_sync(self, msg: Any) -> None:
         """Synchronous entry point for the MatchXMLMask Callback.
 
@@ -843,13 +979,16 @@ class XmppComm(Comm):
                         for callback in callbacks:
                             callback(state_obj)
         else:
-            asyncio.create_task(self._handle_event(msg))
+            asyncio.create_task(self._handle_event(msg, node))
 
-    async def _handle_event(self, msg: Any) -> None:
+    async def _handle_event(self, msg: Any, node: str) -> None:
         """Handles an event.
 
         Args:
             msg: Received XMPP message.
+            node: pubsub node id the event arrived on. Notifications from the shared pubsub
+                service come "from" that service, not from the publisher, so the publishing
+                module's name has to come from the node id (see _event_node) instead of msg["from"].
         """
 
         # get body, unescape it, parse it
@@ -863,8 +1002,13 @@ class XmppComm(Comm):
             # ignore this message
             return
 
-        # did we send this?
-        if msg["from"] == self.client.boundjid.bare:
+        from_module = self._event_node_module(node)
+        if from_module is None:
+            return
+
+        # did we send this? (we never subscribe to our own node, so this shouldn't happen, but
+        # stay defensive rather than assume)
+        if self._module is not None and from_module == self._module.name:
             return
 
         # create event and check timestamp
@@ -877,7 +1021,7 @@ class XmppComm(Comm):
             return
 
         # send it to module
-        self._send_event_to_module(event, msg["from"].username)
+        self._send_event_to_module(event, from_module)
 
     async def _safe_send(self, method: Callable[..., Coroutine[Any, Any, Any]], *args: Any, **kwargs: Any) -> Any:
         """Safely send an XMPP message.

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/images/image.py

@@ -196,6 +196,32 @@ class Image:
             # load image
             return cls._from_hdu_list(d)
 
+    @classmethod
+    def from_ndarray(cls, data: npt.NDArray[Any], meta: dict[str, Any]) -> Image:
+        """Create an Image from a raw numpy array and a metadata dict.
+
+        This is the consumer side of BaseVideo's raw-frame wire format: the meta dict
+        carries FITS keywords (plus a DTYPE entry used to decode the raw bytes on the
+        wire) and is mapped straight onto a FITS header, bypassing FITS bytes entirely.
+
+        Args:
+            data: Numpy array of pixel data.
+            meta: Dictionary of metadata -- FITS keywords plus an optional DTYPE marker.
+
+        Returns:
+            New image.
+        """
+
+        # build header from the FITS-named keys, skipping the DTYPE marker
+        header = fits.Header()
+        for key, value in meta.items():
+            if key == "DTYPE":
+                continue
+            header[key] = value
+
+        # create image (also sets NAXIS1/NAXIS2 from the data shape)
+        return cls(data=data, header=header)
+
     @classmethod
     def from_file(cls, filename: str) -> Image:
         """Create image from FITS file.

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/interfaces/IVideo.py

@@ -8,7 +8,8 @@ from .IData import IData
 
 @dataclass
 class VideoCapabilities:
-    video: str = ""
+    mjpeg: str | None = None
+    raw: str | None = None
 
 
 class IVideo(IData, metaclass=ABCMeta):

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/mixins/fitsheader.py

@@ -31,6 +31,7 @@ class FitsHeaderMixin:
         filenames: str = "/cache/pyobs-{DAY-OBS|date:}-{FRAMENUM|string:04d}.fits",
         frame_number: bool = True,
         night_obs: bool = True,
+        fits_header_timeout: float = 15.0,
         **kwargs: Any,
     ):
         """Initialise the mixin.
@@ -41,6 +42,9 @@ class FitsHeaderMixin:
             filename: Filename pattern for FITS images.
             frame_number: Whether to add frame number to FITS file header.
             night_obs: If True, DAY-OBS will contain the night of observation, not the calendar day.
+            fits_header_timeout: Maximum seconds to wait for a peer's FITS headers before skipping
+                them. A peer that never answers (e.g. a laptop put to sleep without closing its
+                client) would otherwise stall the frame for the full XMPP IQ timeout.
         """
         module = cast(Module, self)
 
@@ -48,6 +52,7 @@ class FitsHeaderMixin:
         self._fitsheadermixin_fits_namespaces = fits_namespaces
         self._fitsheadermixin_filename_pattern = filenames
         self._fitsheadermixin_fits_headers = fits_headers if fits_headers is not None else {}
+        self._fitsheadermixin_header_timeout = fits_header_timeout
         if "OBSERVER" not in self._fitsheadermixin_fits_headers:
             self._fitsheadermixin_fits_headers["OBSERVER"] = ["pyobs", "Name of observer"]
         self._fitsheadermixin_night_obs = night_obs
@@ -98,12 +103,28 @@ class FitsHeaderMixin:
             futures: Futures to get headers from.
         """
 
+        # Bound the whole collection to a single deadline: a peer that never answers its
+        # IQ (e.g. a laptop put to sleep without closing its client) would otherwise stall
+        # the frame for the full XMPP IQ timeout (~120s) per dead peer. Give up on anything
+        # still pending and proceed without its headers.
+        pending: set[Task[Any]] = set()
+        if futures:
+            _, pending = await asyncio.wait(futures.values(), timeout=self._fitsheadermixin_header_timeout)
+            for task in pending:
+                task.cancel()
+            if pending:
+                await asyncio.gather(*pending, return_exceptions=True)
+
         # get fits headers from other clients
         for client, future in futures.items():
             # join thread
             log.info("Fetching FITS headers from %s...", client)
+            if future in pending:
+                log.warning("Could not fetch FITS headers from %s: timed out.", client)
+                continue
+
             try:
-                headers = await future
+                headers = future.result()
             except exc.RemoteError as e:
                 log.warning("Could not fetch FITS headers from %s: %s.", client, str(e))
                 continue
@@ -114,8 +135,13 @@ class FitsHeaderMixin:
                 for key, entry in headers.items():
                     image.header[key] = (entry.value, entry.comment)
 
-    async def add_fits_headers(self, image: Image | fits.PrimaryHDU) -> None:
-        """Add requested FITS headers to header of given image.
+    def add_local_fits_headers(self, image: Image | fits.PrimaryHDU) -> None:
+        """Add the cheap, local FITS headers to the given image (no I/O, no comm).
+
+        This is the always-on half of add_fits_headers(): the configured static
+        fits_headers dict plus the computed fields from _fitsheadermixin_add_fits_headers().
+        The frame-sequence-number step is deliberately kept out (it does a VFS read+write
+        per call), so video-rate callers can reuse this without hitting the VFS on every frame.
 
         Args:
             image: Image with header to add to.
@@ -130,6 +156,18 @@ class FitsHeaderMixin:
 
         # add more fits headers
         self._fitsheadermixin_add_fits_headers(image)
+
+    async def add_fits_headers(self, image: Image | fits.PrimaryHDU) -> None:
+        """Add requested FITS headers to header of given image.
+
+        Args:
+            image: Image with header to add to.
+        """
+
+        # cheap, local half
+        self.add_local_fits_headers(image)
+
+        # persistent nightly frame-sequence number (VFS I/O -- not per-frame safe)
         if self._fitsheadermixin_enable_frame_number:
             await self._fitsheadermixin_add_framenum(image)
 
@@ -281,6 +319,7 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
         self._fitsheadermixin_warned_cdelt = False
         self._fitsheadermixin_warned_crpix = False
         self._fitsheadermixin_warned_cd_matrix = False
+        self._fitsheadermixin_warned_centre = False
 
     @property
     def rotation(self) -> float | None:
@@ -335,8 +374,9 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
         if self._fitsheadermixin_centre is not None:
             hdr["DET-CPX1"] = (self._fitsheadermixin_centre[0], "x-pixel on mechanical axis in unbinned image")
             hdr["DET-CPX2"] = (self._fitsheadermixin_centre[1], "y-pixel on mechanical axis in unbinned image")
-        else:
+        elif not self._fitsheadermixin_warned_centre:
             log.warning("Could not calculate DET-CPX1/DET-CPX2 (centre not given in config).")
+            self._fitsheadermixin_warned_centre = True
 
         # reference pixel in binned image
         if "DET-CPX1" in hdr and "DET-BIN1" in hdr and "DET-CPX2" in hdr and "DET-BIN2" in hdr:

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/mixins/weatheraware.py

@@ -76,13 +76,14 @@ class WeatherAwareMixin:
             # do we need to park?
             if motion_status not in [MotionStatus.PARKED, MotionStatus.PARKING]:
                 # error state?
-                if is_error_state and not self.__weatheraware_is_error_state:
-                    log.error("Telescope is in error mode, cannot park.")
+                if is_error_state:
+                    # only log once when entering error state, and never try to park
+                    # while it persists -- park() would just raise again every cycle
+                    if not self.__weatheraware_is_error_state:
+                        log.error("Telescope is in error mode, cannot park.")
                 else:
-                    # parking?
-                    if motion_status != MotionStatus.PARKED:
-                        log.warning("Weather is bad, shutting down.")
-                        await msi.park()
+                    log.warning("Weather is bad, shutting down.")
+                    await msi.park()
 
             # save error state
             self.__weatheraware_is_error_state = is_error_state

{pyobs_core-2.0.0.dev76 → pyobs_core-2.0.0.dev78}/pyobs/modules/camera/basecamera.py

@@ -60,6 +60,7 @@ class BaseCamera(
         filenames: str = "/cache/pyobs-{DAY-OBS|date:}-{FRAMENUM|string:04d}-{IMAGETYP|type}00.fits.gz",
         fits_namespaces: list[str] | None = None,
         meridian_flip_on: str | None = None,
+        fits_header_timeout: float = 15.0,
         **kwargs: Any,
     ):
         """Creates a new BaseCamera.
@@ -73,6 +74,7 @@ class BaseCamera(
             flip_y: Whether or not to flip the image along its second axis.
             filenames: Template for file naming.
             fits_namespaces: List of namespaces for FITS headers that this camera should request
+            fits_header_timeout: Maximum seconds to wait for a peer's FITS headers before skipping them.
         """
         Module.__init__(self, **kwargs)
         ImageFitsHeaderMixin.__init__(
@@ -82,6 +84,7 @@ class BaseCamera(
             centre=centre,
             rotation=rotation,
             filenames=filenames,
+            fits_header_timeout=fits_header_timeout,
         )
 
         # check