pyobs-core 2.0.0.dev27__tar.gz → 2.0.0.dev29__tar.gz

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/PKG-INFO

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

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/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.dev27 → pyobs_core-2.0.0.dev29}/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.dev27 → pyobs_core-2.0.0.dev29}/pyobs/comm/xmpp/rpc.py

@@ -96,9 +96,22 @@ def fault_to_xml(exception: Exception) -> ET.Element:
     value_elem = ET.Element(f"{{{_NS}}}value")
     pyobs_fault = ET.Element(f"{{{_PYOBS_NS}}}fault")
     exc_elem = ET.Element("exception")
-    exc_elem.text = type(exception).__name__
+    # Fully-qualified name, not the bare class name -- domain exceptions can live anywhere, not
+    # just in pyobs.utils.exceptions (see PyobsError._registry / resolve()). If this is an
+    # UnclassifiedError wrapping something that was never a PyobsError to begin with (see
+    # Module.execute()'s classification), serialize the ORIGINAL type's name instead of
+    # "UnclassifiedError" itself -- original_type never crosses the wire as an attribute (only the
+    # class name and message do), so this is the only way it survives to the caller. The caller's
+    # own registry lookup then decides fresh: an unregistered builtin/vendor type still correctly
+    # falls back to UnclassifiedError, but this time with original_type actually populated.
+    original_type = getattr(exception, "original_type", None)
+    exc_elem.text = original_type if original_type else f"{type(exception).__module__}.{type(exception).__qualname__}"
     msg_elem = ET.Element("message")
-    msg_elem.text = str(exception)
+    # the raw message, not str(exception) -- str() already prepends "<ClassName>", and
+    # reconstruction on the caller's side passes this straight back in as the new instance's
+    # message, so serializing str() here would bake in a doubled "<ClassName> <ClassName> ..." once
+    # the caller's own __str__ formats it again
+    msg_elem.text = getattr(exception, "message", None) or str(exception)
     pyobs_fault.append(exc_elem)
     pyobs_fault.append(msg_elem)
     value_elem.append(pyobs_fault)
@@ -107,16 +120,17 @@ def fault_to_xml(exception: Exception) -> ET.Element:
 
 
 def xml_to_fault(fault_elem: ET.Element) -> tuple[str, str]:
-    """Parse <fault> and return (exception_class_name, message)."""
+    """Parse <fault> and return (exception_qualified_name, message)."""
+    _fallback_name = f"{exc.RemoteError.__module__}.{exc.RemoteError.__qualname__}"
     value_elem = fault_elem.find(f"{{{_NS}}}value")
     if value_elem is None:
-        return "RemoteError", "Unknown error"
+        return _fallback_name, "Unknown error"
     pyobs_fault = value_elem.find(f"{{{_PYOBS_NS}}}fault")
     if pyobs_fault is None:
-        return "RemoteError", "Unknown error"
+        return _fallback_name, "Unknown error"
     exc_el = pyobs_fault.find("exception")
     msg_el = pyobs_fault.find("message")
-    exc_name = (exc_el.text if exc_el is not None else None) or "RemoteError"
+    exc_name = (exc_el.text if exc_el is not None else None) or _fallback_name
     msg = (msg_el.text if msg_el is not None else None) or ""
     return exc_name, msg
 
@@ -170,6 +184,13 @@ class RPC:
         iq.enable("rpc_query")
         pmethod = iq["rpc_query"]["method_call"]["method_name"]
 
+        # XEP-0009 already assigns this per call (used elsewhere as the Future dict key) -- reuse
+        # it as a correlation id so an operator can jump from a caller-side exception straight to
+        # the matching origin-side log line, instead of neither side pointing at the other
+        call_id: str | slixmpp.JID = iq["id"]
+        if isinstance(call_id, slixmpp.JID):
+            call_id = call_id.node
+
         try:
             if self._handler is None:
                 return
@@ -208,7 +229,7 @@ class RPC:
                     response.send()
 
             # Call method
-            return_value = await self._handler.execute(pmethod, *params, sender=iq["from"].user)
+            return_value = await self._handler.execute(pmethod, *params, sender=iq["from"].user, call_id=call_id)
 
             # Serialize return value
             return_type = hints.get("return", type(None))
@@ -220,9 +241,12 @@ class RPC:
             self._client.plugin["xep_0009"].forbidden(iq).send()
 
         except Exception as e:
-            if isinstance(e, exc.PyObsError):
-                e.log(log, "ERROR", f"Exception in call to {pmethod}: {e}", exc_info=True)
-            else:
+            # Module.execute() already classified and logged anything raised by the call itself
+            # (every transport gets the same treatment there now), so there's nothing left to do
+            # here but serialize and send the fault -- except for failures that never reached
+            # execute() at all (e.g. malformed RPC parameters during deserialization above), which
+            # this is the only place that will ever log
+            if not isinstance(e, exc.PyobsError):
                 log.exception("Unexpected exception in %s.", pmethod)
             self._client.plugin["xep_0009"].send_fault(iq, fault_to_xml(e))
 
@@ -269,18 +293,22 @@ class RPC:
         fault_elem = iq["rpc_query"]["method_response"]["fault"]
         exc_name, msg = xml_to_fault(fault_elem)
 
-        exception_class = getattr(exc, exc_name, None)
-        if exception_class is None or not issubclass(exception_class, Exception):
-            exception_class = exc.RemoteError
-
         sender = iq["from"].node
-        if issubclass(exception_class, exc.RemoteError):
-            exception = exception_class(message=msg, module=sender)
+        exception_class = exc.PyobsError.resolve(exc_name)
+        if exception_class is not None:
+            # real registered type (e.g. FocusError) -- raised as itself, not wrapped
+            exception: exc.PyobsError = exception_class(msg, remote_module=sender)
         else:
-            exception = exception_class(msg)
+            # unresolvable: never a PyobsError to begin with, or its defining module was never
+            # imported in this process -- the qualified name string still survives as original_type
+            exception = exc.UnclassifiedError(msg, original_type=exc_name, remote_module=sender)
+
+        # same correlation id Module.execute() logged on the origin side -- an operator can jump
+        # straight from this caller-side exception to the matching detailed log line, by id
+        setattr(exception, "call_id", jid)
 
         if not future.done():
-            future.set_exception(exc.InvocationError(module=sender, exception=exception))
+            future.set_exception(exception)
 
     async def _on_jabber_rpc_error(self, iq: Any) -> None:
         pmethod = self._client.plugin["xep_0009"].extract_method(iq["rpc_query"])
@@ -295,12 +323,16 @@ class RPC:
 
         sender = iq["from"].node
         e = {
-            "item-not-found": exc.RemoteError(sender, f"No remote handler for {pmethod} at {iq['from']}!"),
-            "forbidden": exc.RemoteError(sender, f"Forbidden to invoke {pmethod} at {iq['from']}!"),
-            "undefined-condition": exc.RemoteError(sender, f"Unexpected problem invoking {pmethod} at {iq['from']}!"),
-            "service-unavailable": exc.RemoteError(sender, f"Service at {iq['from']} is unavailable."),
-            "remote-server-not-found": exc.RemoteError(sender, f"Could not find remote server for {iq['from']}."),
-        }.get(condition, exc.RemoteError(sender, f"Unexpected exception at {iq['from']}!"))
+            "item-not-found": exc.RemoteError(f"No remote handler for {pmethod} at {iq['from']}!", module=sender),
+            "forbidden": exc.RemoteError(f"Forbidden to invoke {pmethod} at {iq['from']}!", module=sender),
+            "undefined-condition": exc.RemoteError(
+                f"Unexpected problem invoking {pmethod} at {iq['from']}!", module=sender
+            ),
+            "service-unavailable": exc.RemoteError(f"Service at {iq['from']} is unavailable.", module=sender),
+            "remote-server-not-found": exc.RemoteError(
+                f"Could not find remote server for {iq['from']}.", module=sender
+            ),
+        }.get(condition, exc.RemoteError(f"Unexpected exception at {iq['from']}!", module=sender))
 
         callback.set_exception(e)
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/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.dev27 → pyobs_core-2.0.0.dev29}/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
@@ -503,10 +521,10 @@ class XmppComm(Comm):
             # RPC layer's jabber_rpc_error event handling ever gets a chance to act on it,
             # so the IQ-level "forbidden" condition (see Module ACLs) has to be read here.
             if e.iq["error"]["condition"] == "forbidden":
-                raise exc.RemoteError(client, f"Forbidden to invoke {method} on {client}.")
-            raise exc.RemoteError(client, f"Could not call {method} on {client}.")
+                raise exc.RemoteError(f"Forbidden to invoke {method} on {client}.", module=client)
+            raise exc.RemoteError(f"Could not call {method} on {client}.", module=client)
         except slixmpp.exceptions.IqTimeout:
-            raise exc.RemoteTimeoutError(client, f"Call to {method} on {client} timed out.")
+            raise exc.RemoteTimeoutError(f"Call to {method} on {client} timed out.", module=client)
 
     async def _got_online(self, msg: Any) -> None:
         """If a new client connects, add it to list.
@@ -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.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IAcquisition.py

@@ -59,7 +59,10 @@ class IAcquisition(IRunning, IAbortable, metaclass=ABCMeta):
             Result with time, ra, dec, alt, az, and an offset in whichever frame the mount supports.
 
         Raises:
-            ValueError: If target could not be acquired.
+            AbortedError: If the acquisition was aborted.
+            GeneralError: If a dependency (e.g. the camera) failed.
+            ImageError: If the calculated offset was too large or otherwise unusable.
+            AcquisitionError: If target could not be acquired within the given tolerance.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IAutoFocus.py

@@ -54,7 +54,8 @@ class IAutoFocus(IRunning, IAbortable, metaclass=ABCMeta):
             Result of autofocus.
 
         Raises:
-            ValueError: If focus could not be obtained.
+            AbortedError: If the autofocus series was aborted.
+            FocusError: If focus could not be obtained.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/ICalibrate.py

@@ -11,7 +11,11 @@ class ICalibrate(Interface, metaclass=ABCMeta):
 
     @abstractmethod
     async def calibrate(self, **kwargs: Any) -> None:
-        """Calibrate the device."""
+        """Calibrate the device.
+
+        Raises:
+            GeneralError: If calibration failed.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IConfig.py

@@ -33,7 +33,7 @@ class IConfig(Interface, metaclass=ABCMeta):
             Current value.
 
         Raises:
-            ValueError: If config item of given name does not exist.
+            InvalidArgumentError: If config item of given name does not exist.
         """
         ...
 
@@ -46,7 +46,8 @@ class IConfig(Interface, metaclass=ABCMeta):
             value: New value.
 
         Raises:
-            ValueError: If config item of given name does not exist or value is invalid.
+            InvalidArgumentError: If config item of given name does not exist.
+            ValueError: If value is invalid.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IData.py

@@ -20,6 +20,7 @@ class IData(Interface, metaclass=ABCMeta):
             Name of image that was taken.
 
         Raises:
+            DeviceBusyError: If the device is already busy (exposing or running a sequence).
             GrabImageError: If there was a problem grabbing the image.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IDataSequence.py

@@ -38,7 +38,8 @@ class IDataSequence(IAbortable, metaclass=ABCMeta):
                 during the wait.
 
         Raises:
-            GrabImageError: If the device is already busy (exposing or already running a
+            InvalidArgumentError: If count or delay is out of range.
+            DeviceBusyError: If the device is already busy (exposing or already running a
                 sequence).
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IExposureTime.py

@@ -31,6 +31,8 @@ class IExposureTime(Interface, metaclass=ABCMeta):
 
         Raises:
             ValueError: If exposure time could not be set.
+            NotSupportedError: If this module doesn't support setting exposure time directly (e.g.
+                it's dictated by something else, like incoming science frames).
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IFilters.py

@@ -35,7 +35,7 @@ class IFilters(IMotion, metaclass=ABCMeta):
             filter_name: Name of filter to set.
 
         Raises:
-            ValueError: If an invalid filter was given.
+            InvalidArgumentError: If an invalid filter was given.
             MoveError: If filter wheel cannot be moved.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IFlatField.py

@@ -21,6 +21,9 @@ class IFlatField(IAbortable, metaclass=ABCMeta):
 
         Returns:
             Number of images actually taken and total exposure time in seconds
+
+        Raises:
+            DeviceBusyError: If a flat-fielding run is already in progress.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IFocusModel.py

@@ -21,7 +21,13 @@ class IFocusModel(Interface, metaclass=ABCMeta):
 
     @abstractmethod
     async def set_optimal_focus(self, **kwargs: Any) -> None:
-        """Sets optimal focus."""
+        """Sets optimal focus.
+
+        Raises:
+            WeatherDataError: If the weather station returned an invalid temperature reading.
+            FocusTimeoutError: If a temperature module didn't respond in time.
+            MissingSensorError: If a configured sensor isn't in a module's temperature data.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IFocuser.py

@@ -31,8 +31,9 @@ class IFocuser(IMotion, metaclass=ABCMeta):
             focus: New focus value in mm.
 
         Raises:
+            InvalidArgumentError: If given value is invalid.
+            AbortedError: If movement was aborted.
             MoveError: If telescope cannot be moved.
-            InterruptedError: If movement was aborted.
         """
         ...
 
@@ -45,6 +46,7 @@ class IFocuser(IMotion, metaclass=ABCMeta):
 
         Raises:
             ValueError: If given value is invalid.
+            NotSupportedError: If this module doesn't support a separate focus offset.
             MoveError: If telescope cannot be moved.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IMode.py

@@ -36,7 +36,7 @@ class IMode(Interface, metaclass=ABCMeta):
             group: Name of the group to set the mode for.
 
         Raises:
-            ValueError: If an invalid mode or group was given.
+            InvalidArgumentError: If an invalid mode or group was given.
             MoveError: If mode selector cannot be moved.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IMultiFiber.py

@@ -42,6 +42,9 @@ class IMultiFiber(Interface, metaclass=ABCMeta):
 
         Args:
             fiber: Name of fiber to set.
+
+        Raises:
+            InvalidArgumentError: If fiber name is invalid.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingAltAz.py

@@ -34,6 +34,8 @@ class IPointingAltAz(Interface, metaclass=ABCMeta):
             az: Az in deg to move to.
 
         Raises:
+            NotSupportedError: If this device doesn't support Alt/Az pointing.
+            AltitudeLimitError: If the destination is below the configured altitude limit.
             MoveError: If device could not be moved.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingBody.py

@@ -20,8 +20,11 @@ class IPointingBody(Interface, metaclass=ABCMeta):
                   asteroid/comet designation known to JPL Horizons).
 
         Raises:
-            MoveError: If telescope could not be moved.
-            ValueError: If body name is not resolvable.
+            NotSupportedError: If this device doesn't support body tracking.
+            BodyResolutionError: If body name is not resolvable.
+            MoveError: If telescope could not be moved. Also propagates whatever the underlying
+                RA/Dec move raises (e.g. MissingObserverError, AltitudeLimitError), since tracking
+                a body is implemented as resolving it and then moving there.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingHeliocentricPolar.py

@@ -33,7 +33,9 @@ class IPointingHeliocentricPolar(Interface, metaclass=ABCMeta):
             psi: Position angle around the solar disk, in degrees.
 
         Raises:
-            MoveError: If device could not be moved.
+            MoveError: If device could not be moved. Also propagates whatever the underlying
+                RA/Dec move raises (e.g. MissingObserverError, AltitudeLimitError), since this is
+                typically implemented as converting to RA/Dec and then moving there.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingHeliographicStonyhurst.py

@@ -35,7 +35,9 @@ class IPointingHeliographicStonyhurst(Interface, metaclass=ABCMeta):
             lat: Latitude in deg to track.
 
         Raises:
-            MoveError: If device could not be moved.
+            MoveError: If device could not be moved. Also propagates whatever the underlying
+                RA/Dec move raises (e.g. MissingObserverError, AltitudeLimitError), since this is
+                typically implemented as converting to RA/Dec and then moving there.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingHelioprojective.py

@@ -34,7 +34,9 @@ class IPointingHelioprojective(Interface, metaclass=ABCMeta):
             theta_y: The theta_y coordinate.
 
         Raises:
-            MoveError: If device could not be moved.
+            MoveError: If device could not be moved. Also propagates whatever the underlying
+                RA/Dec move raises (e.g. MissingObserverError, AltitudeLimitError), since this is
+                typically implemented as converting to RA/Dec and then moving there.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingOrbitalElements.py

@@ -37,9 +37,12 @@ class IPointingOrbitalElements(Interface, metaclass=ABCMeta):
             elements: Orbital elements of the body to track.
 
         Raises:
-            MoveError: If telescope could not be moved.
-            ValueError: If elements are incomplete or inconsistent (neither mean_anomaly
-                nor perihelion_time given).
+            NotSupportedError: If this device doesn't support orbital-element tracking.
+            InvalidOrbitalElementsError: If elements are incomplete or inconsistent (neither
+                mean_anomaly nor perihelion_time given).
+            MoveError: If telescope could not be moved. Also propagates whatever the underlying
+                RA/Dec move raises (e.g. MissingObserverError, AltitudeLimitError), since tracking
+                orbital elements is implemented as propagating them and then moving there.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingRaDec.py

@@ -34,6 +34,9 @@ class IPointingRaDec(Interface, metaclass=ABCMeta):
             dec: Dec in deg to track.
 
         Raises:
+            NotSupportedError: If this device doesn't support RA/Dec pointing.
+            MissingObserverError: If no observer is configured.
+            AltitudeLimitError: If the destination is below the configured altitude limit.
             MoveError: If device could not be moved.
         """
         ...

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IPointingSeries.py

@@ -12,7 +12,11 @@ class IPointingSeries(Interface, metaclass=ABCMeta):
 
     @abstractmethod
     async def add_pointing_measurement(self, **kwargs: Any) -> None:
-        """Add a new measurement to the pointing series."""
+        """Add a new measurement to the pointing series.
+
+        Raises:
+            GeneralError: If the measurement could not be added.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IRotation.py

@@ -24,7 +24,11 @@ class IRotation(IMotion, metaclass=ABCMeta):
 
     @abstractmethod
     async def set_rotation(self, angle: Annotated[float, Unit.DEGREES], **kwargs: Any) -> None:
-        """Sets the rotation angle to the given value in degrees."""
+        """Sets the rotation angle to the given value in degrees.
+
+        Raises:
+            MoveError: If the device could not be rotated.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IRunnable.py

@@ -11,7 +11,13 @@ class IRunnable(IAbortable, metaclass=ABCMeta):
 
     @abstractmethod
     async def run(self, **kwargs: Any) -> None:
-        """Perform module task"""
+        """Perform module task
+
+        Raises:
+            DeviceBusyError: If this task is already running.
+            ScriptError: ScriptRunner-based implementations wrap whatever the underlying script
+                raises that isn't already a domain exception.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/IScriptRunner.py

@@ -15,6 +15,9 @@ class IScriptRunner(Interface, metaclass=ABCMeta):
 
         Args:
             script: Script to run.
+
+        Raises:
+            ScriptError: If the script failed.
         """
         ...
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/ISyncTarget.py

@@ -12,7 +12,11 @@ class ISyncTarget(Interface, metaclass=ABCMeta):
 
     @abstractmethod
     async def sync_target(self, **kwargs: Any) -> None:
-        """Synchronize device on current target."""
+        """Synchronize device on current target.
+
+        Raises:
+            GeneralError: If synchronization failed.
+        """
         ...
 
 

{pyobs_core-2.0.0.dev27 → pyobs_core-2.0.0.dev29}/pyobs/interfaces/ITrackingMode.py

@@ -46,7 +46,7 @@ class ITrackingMode(Interface, metaclass=ABCMeta):
 
         Raises:
             MoveError: If mode could not be set.
-            ValueError: If mode is not in this module's capabilities.
+            InvalidArgumentError: If mode is not in this module's capabilities.
         """
         ...