pyobs-core 2.20.0__tar.gz → 2.22.0__tar.gz

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-core
-Version: 2.20.0
+Version: 2.22.0
 Summary: robotic telescope software
 Project-URL: Homepage, https://www.pyobs.org
 Project-URL: Documentation, https://docs.pyobs.org

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/application.py

@@ -65,14 +65,30 @@ def _warm_iers_cache() -> None:
     conversion needs it -- update_leap_seconds() (not the lower-level LeapSeconds.auto_open())
     is the call that also installs the result into erfa so real usage later doesn't re-fetch.
 
+    If the refresh fails, auto-download is disabled for the process and the error re-raised.
+
     Meant to run inside an executor thread (see Application._main) -- calling this directly
     on the event loop would defeat the point.
     """
+    from astropy.time import Time
     from astropy.time.core import update_leap_seconds
     from astropy.utils.iers import IERS_Auto
 
-    IERS_Auto.open()
-    update_leap_seconds()
+    try:
+        table = IERS_Auto.open()
+        # open() alone does not refresh a stale table: that only happens on the first lookup
+        # for an actual time (IERS_Auto._interpolate -> _refresh_table_as_needed), which would
+        # otherwise be the first alt/az on the event loop. Do that lookup here, covering both
+        # UT1-UTC and polar motion.
+        now = Time.now()
+        table.ut1_utc(now)
+        table.pm_xy(now)
+        update_leap_seconds()
+    except Exception:
+        # refresh failed (e.g. offline): astropy would otherwise raise (or retry the download)
+        # on every later alt/az, so fall back to the bundled table for this process
+        _disable_iers_auto_download()
+        raise
 
 
 class InfluxLogConfig(TypedDict):

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/comm/comm.py

@@ -423,16 +423,19 @@ class Comm:
 
     async def register_event(self, event_class: type[Event], handler: EventHandler | None = None) -> None:
         """Register an event type. If a handler is given, we also receive those events, otherwise we just
-        send them. Event classes derived from the given one are registered, too, but only those that have been
-        imported (and therefore registered) by now.
+        send them.
+
+        With a handler, event classes derived from the given one are subscribed, too, but only those that have
+        been imported (and therefore registered) by now. Without a handler, only the given class itself is
+        declared as sent: a module that sends several related events registers each of them.
 
         Args:
             event_class: Class of event to register.
             handler: Event handler method.
         """
 
-        # we also want to register all events derived from the given one
-        event_classes = self._get_derived_events(event_class)
+        # a handler also covers derived events, but we only declare to send exactly the given class
+        event_classes = self._get_derived_events(event_class) if handler else [event_class]
 
         # do we have a handler? then we subscribe, otherwise we just declare that we send it
         if handler:

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/comm/xmpp/rpc.py

@@ -135,17 +135,38 @@ def fault_to_xml(exception: Exception) -> ET.Element:
     return fault
 
 
+def _pyobs_fault(fault_elem: ET.Element) -> ET.Element | None:
+    """Return the <pyobs:fault> element inside a <fault><value>, or None."""
+    value_elem = fault_elem.find(f"{{{_NS}}}value")
+    if value_elem is None:
+        return None
+    return value_elem.find(f"{{{_PYOBS_NS}}}fault")
+
+
+def _fault_child(parent: ET.Element, name: str) -> ET.Element | None:
+    """Find a child of a fault element, with or without the pyobs namespace.
+
+    Depending on the sender's slixmpp version, the children of <pyobs:fault> go over the wire either with
+    an explicit xmlns="" (slixmpp >= 1.17, parsed without namespace) or without it, in which case they
+    inherit urn:pyobs:rpc:1 from their parent when parsed (slixmpp <= 1.16). Both forms must be accepted (#1030).
+    """
+    child = parent.find(f"{{{_PYOBS_NS}}}{name}")
+    return child if child is not None else parent.find(name)
+
+
 def xml_to_fault(fault_elem: ET.Element) -> tuple[str, str]:
     """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:
+    if fault_elem.find(f"{{{_NS}}}value") is None:
         return _fallback_name, "Unknown error"
-    pyobs_fault = value_elem.find(f"{{{_PYOBS_NS}}}fault")
+    pyobs_fault = _pyobs_fault(fault_elem)
     if pyobs_fault is None:
         return _fallback_name, "Unknown error"
-    exc_el = pyobs_fault.find("exception")
-    msg_el = pyobs_fault.find("message")
+    exc_el = _fault_child(pyobs_fault, "exception")
+    msg_el = _fault_child(pyobs_fault, "message")
+    if exc_el is None:
+        # would otherwise silently become an empty RemoteError, which is how #1030 stayed hidden
+        log.warning("Received fault without exception element: %s", ET.tostring(fault_elem, encoding="unicode"))
     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
@@ -156,13 +177,13 @@ def xml_to_fault_bases(fault_elem: ET.Element) -> list[str]:
 
     Empty if the fault has none, e.g. when it comes from a peer that does not send them.
     """
-    value_elem = fault_elem.find(f"{{{_NS}}}value")
-    if value_elem is None:
-        return []
-    pyobs_fault = value_elem.find(f"{{{_PYOBS_NS}}}fault")
+    pyobs_fault = _pyobs_fault(fault_elem)
     if pyobs_fault is None:
         return []
-    return [b.text for b in pyobs_fault.iterfind("bases/base") if b.text]
+    bases_elem = _fault_child(pyobs_fault, "bases")
+    if bases_elem is None:
+        return []
+    return [b.text for b in bases_elem if b.tag.split("}")[-1] == "base" and b.text]
 
 
 def reconstruct_fault(name: str, message: str, bases: list[str], remote_module: str) -> exc.PyobsError:

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/events/__init__.py

@@ -17,6 +17,7 @@ from .moduleclosed import ModuleClosedEvent
 from .moduleopened import ModuleOpenedEvent
 from .motionstatuschanged import MotionStatusChangedEvent
 from .move import MoveAltAzEvent, MoveEvent, MoveRaDecEvent
+from .newdata import NewDataEvent
 from .newimage import NewImageEvent
 from .newspectrum import NewSpectrumEvent
 from .offsets import OffsetsAltAzEvent, OffsetsEvent, OffsetsRaDecEvent
@@ -47,6 +48,7 @@ __all__ = [
     "MoveEvent",
     "MoveRaDecEvent",
     "MoveAltAzEvent",
+    "NewDataEvent",
     "NewImageEvent",
     "NewSpectrumEvent",
     "RoofClosingEvent",

pyobs_core-2.22.0/pyobs/events/newdata.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+from pyobs.events.event import Event
+
+
+class DataType(TypedDict):
+    filename: str
+
+
+class NewDataEvent(Event):
+    """Event to be sent on new data, e.g. a file that is neither an image nor a spectrum.
+
+    ``filename`` is a VFS path. :class:`NewImageEvent` and :class:`NewSpectrumEvent` derive from this class, so a
+    handler registered for ``NewDataEvent`` also receives those; use ``type(event) is NewDataEvent`` to select only
+    generic data.
+    Registering ``NewDataEvent`` without a handler declares only this class as sent, not the derived events.
+    """
+
+    __module__ = "pyobs.events"
+
+    def __init__(self, filename: str, **kwargs: Any):
+        """Initializes new NewDataEvent.
+
+        Args:
+            filename: Name of new data file.
+        """
+        Event.__init__(self)
+        self.data: DataType = {"filename": filename}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> Event:
+        # get filename
+        if "filename" not in d or not isinstance(d["filename"], str):
+            raise ValueError("Invalid type for filename.")
+        filename: str = d["filename"]
+
+        # return object
+        return cls(filename)
+
+    @property
+    def filename(self) -> str:
+        return self.data["filename"]
+
+
+__all__ = ["NewDataEvent"]

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/events/newimage.py

@@ -1,18 +1,19 @@
 from __future__ import annotations
 
-from typing import Any, TypedDict
+from typing import Any
 
 from pyobs.events.event import Event
+from pyobs.events.newdata import DataType as NewDataType
+from pyobs.events.newdata import NewDataEvent
 from pyobs.utils.enums import ImageType
 
 
-class DataType(TypedDict):
-    filename: str
+class DataType(NewDataType):
     image_type: str | None
     raw: str | None
 
 
-class NewImageEvent(Event):
+class NewImageEvent(NewDataEvent):
     """Event to be sent on a new image."""
 
     __module__ = "pyobs.events"
@@ -25,7 +26,7 @@ class NewImageEvent(Event):
             image_type: Type of image.
             raw: Only for reduced images, references raw frame.
         """
-        Event.__init__(self)
+        NewDataEvent.__init__(self, filename)
         self.data: DataType = {
             "filename": filename,
             "image_type": image_type if image_type is not None else None,
@@ -50,11 +51,7 @@ class NewImageEvent(Event):
             raw = d["raw"]
 
         # return object
-        return NewImageEvent(filename, image_type, raw)
-
-    @property
-    def filename(self) -> str:
-        return self.data["filename"]
+        return cls(filename, image_type, raw)
 
     @property
     def image_type(self) -> ImageType | None:

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/events/newspectrum.py

@@ -1,16 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, TypedDict
+from typing import Any
 
 from pyobs.events.event import Event
+from pyobs.events.newdata import DataType, NewDataEvent
 
 
-class DataType(TypedDict):
-    filename: str
-
-
-class NewSpectrumEvent(Event):
-    """Event to be sent on a new image."""
+class NewSpectrumEvent(NewDataEvent):
+    """Event to be sent on a new spectrum."""
 
     __module__ = "pyobs.events"
 
@@ -18,9 +15,9 @@ class NewSpectrumEvent(Event):
         """Initializes new NewSpectrumEvent.
 
         Args:
-            filename: Name of new image file.
+            filename: Name of new spectrum file.
         """
-        Event.__init__(self)
+        NewDataEvent.__init__(self, filename)
         self.data: DataType = {"filename": filename}
 
     @classmethod
@@ -31,11 +28,7 @@ class NewSpectrumEvent(Event):
         filename: str = d["filename"]
 
         # return object
-        return NewSpectrumEvent(filename)
-
-    @property
-    def filename(self) -> str:
-        return self.data["filename"]
+        return cls(filename)
 
 
 __all__ = ["NewSpectrumEvent"]

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/interfaces/IMotion.py

@@ -36,6 +36,8 @@ class IMotion(IReady, metaclass=ABCMeta):
 
         Raises:
             InitError: If device could not be initialized.
+            InitAbortedError: If initialization was interrupted on purpose (e.g. by park() or stop_motion()); not a
+                device fault.
         """
         ...
 

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/mixins/fitsheader.py

@@ -103,7 +103,7 @@ async def add_requested_fits_headers(
 
         try:
             headers = future.result()
-        except exc.RemoteError as e:
+        except exc.PyobsError as e:
             log.warning("Could not fetch FITS headers from %s: %s.", client, str(e))
             continue
         except Exception as e:

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/mixins/follow.py

@@ -173,7 +173,7 @@ class FollowMixin:
                     continue
                 other_coords = build_skycoord(xy_coords, this.__follow_mode)
                 connected = True
-            except (ValueError, exc.RemoteError):
+            except (ValueError, exc.PyobsError):
                 if connected:
                     log.warning("Could not fetch coordinates.")
                 connected = False

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/modules/camera/__init__.py

@@ -6,6 +6,7 @@ TODO: write doc
 __title__ = "Cameras"
 
 from .basecamera import BaseCamera
+from .basedata import BaseData
 from .basespectrograph import BaseSpectrograph
 from .basevideo import BaseVideo
 from .dummycamera import DummyCamera
@@ -15,6 +16,7 @@ from .videoframes import Frame, FrameRecord, StartSource
 
 __all__ = [
     "BaseCamera",
+    "BaseData",
     "BaseVideo",
     "BaseSpectrograph",
     "DummyCamera",

pyobs_core-2.22.0/pyobs/modules/camera/basedata.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import logging
+from abc import ABCMeta
+from typing import Any
+
+from pyobs.events import NewDataEvent
+from pyobs.interfaces import IData
+from pyobs.mixins.datasequence import DataSequenceMixin
+from pyobs.mixins.fitsheader import FitsHeaderMixin
+from pyobs.modules import Module
+
+log = logging.getLogger(__name__)
+
+
+class BaseData(Module, FitsHeaderMixin, IData, DataSequenceMixin, metaclass=ABCMeta):
+    """Base class for modules that grab data that is neither an image nor a spectrum.
+
+    Provides the FITS header handling and file naming of :class:`~pyobs.mixins.FitsHeaderMixin`, grab sequences
+    via :class:`~pyobs.mixins.DataSequenceMixin`, and sends a :class:`~pyobs.events.NewDataEvent` for new data.
+    Derived classes implement ``grab_data()`` and ``_sequence_busy()``, call :meth:`_send_new_data` once the data
+    is stored, and extend :meth:`abort` with the actual hardware abort.
+    """
+
+    __module__ = "pyobs.modules.camera"
+
+    def __init__(
+        self,
+        fits_headers: dict[str, Any] | None = None,
+        filenames: str = "/cache/pyobs-{DAY-OBS|date:}-{FRAMENUM|string:04d}.fits.gz",
+        fits_namespaces: list[str] | None = None,
+        **kwargs: Any,
+    ):
+        """Creates a new BaseData.
+
+        Args:
+            fits_headers: Additional FITS headers.
+            filenames: Template for file naming.
+            fits_namespaces: List of namespaces for FITS headers that this module should request.
+        """
+        super().__init__(fits_namespaces=fits_namespaces, fits_headers=fits_headers, filenames=filenames, **kwargs)
+
+        if self._comm is None:
+            log.warning("No comm module given, will not be able to signal new data!")
+
+    async def open(self) -> None:
+        """Open module."""
+        await Module.open(self)
+
+        # declare the event we send, exactly this class (NewImageEvent and NewSpectrumEvent are not sent)
+        if self._comm:
+            await self.comm.register_event(NewDataEvent)
+
+        # publish initial state
+        await self._datasequence_open()
+
+    async def _send_new_data(self, filename: str, broadcast: bool = True) -> None:
+        """Send a NewDataEvent for stored data.
+
+        Args:
+            filename: VFS path of the stored data.
+            broadcast: Whether to send the event at all.
+        """
+        if broadcast and self._comm:
+            await self.comm.send_event(NewDataEvent(filename))
+
+    async def abort(self, **kwargs: Any) -> None:
+        """Aborts the current grab and sequence. Derived classes must implement the actual hardware abort and
+        call this."""
+        self._abort_data_sequence()
+
+
+__all__ = ["BaseData"]

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/modules/camera/basespectrograph.py

@@ -65,6 +65,11 @@ class BaseSpectrograph(
         """Open module."""
         await Module.open(self)
 
+        # declare the events we send
+        if self._comm:
+            await self.comm.register_event(NewSpectrumEvent)
+            await self.comm.register_event(ExposureStatusChangedEvent)
+
         # publish initial state
         await self.comm.set_state(
             IExposure, ExposureState(status=self._spectrograph_status, progress=0.0, exposure_time_left=0.0)

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/modules/module.py

@@ -251,7 +251,8 @@ class Module(Object, IModule, IConfig):
 
         Args:
             exc_type: Exception type (or a shared ancestor) to watch for. RemoteError also
-                counts remote domain faults, except expected PointingLimitError rejections.
+                counts remote domain faults, except expected PointingLimitError and
+                InitAbortedError rejections.
             limit: Number of occurrences that triggers the callback.
             timespan: If given, only count occurrences within the last timespan seconds.
             module: If given, only count occurrences tagged as coming from this remote module
@@ -281,17 +282,19 @@ class Module(Object, IModule, IConfig):
 
     @staticmethod
     def _counts_as_remote_error(exception: Exception) -> bool:
-        """Classify remote domain failures for broad handlers, excluding expected pointing rejections.
+        """Classify remote domain failures for broad handlers, excluding expected rejections.
+
+        Expected rejections are PointingLimitError and InitAbortedError.
 
         Actual RemoteError inheritance and explicit domain handlers are handled separately.
         """
         return getattr(exception, "remote_module", None) is not None and not isinstance(
-            exception, exc.PointingLimitError
+            exception, exc.PointingLimitError | exc.InitAbortedError
         )
 
     def _store_exception(self, exception: exc.PyobsError, module: str | None) -> None:
         # Preserve actual ancestors and classify eligible remote domain faults as RemoteError
-        # for broad severity handlers. Expected pointing rejections retain their domain buckets.
+        # for broad severity handlers. Expected rejections (pointing limits, aborted init) retain their domain buckets.
         classes: list[type] = list(type(exception).__mro__)
         if self._counts_as_remote_error(exception) and exc.RemoteError not in classes:
             classes.append(exc.RemoteError)

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/modules/robotic/mastermind.py

@@ -43,7 +43,7 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
         runner: TaskRunner | dict[str, Any],
         tasks: TaskArchive | dict[str, Any] | None = None,
         allowed_late_start: int = 300,
-        allowed_overrun: int = 300,
+        allowed_overrun: int | None = 300,
         after_task_sleep: int = 0,
         **kwargs: Any,
     ):
@@ -52,7 +52,8 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
         Args:
             schedule: Object that can return schedule.
             allowed_late_start: Allowed seconds to start late.
-            allowed_overrun: Allowed time for a task to exceed it's window in seconds
+            allowed_overrun: Allowed time for a task to exceed its window in seconds, after which it is aborted.
+                None disables the check.
         """
         Module.__init__(self, **kwargs)
 
@@ -119,6 +120,7 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
         # subscribe to events
         if self._comm:
             await self.comm.register_event(TaskStartedEvent)
+            await self.comm.register_event(TaskFailedEvent)
             await self.comm.register_event(TaskFinishedEvent)
             await self.comm.register_event(TaskSkippedEvent)
 
@@ -141,6 +143,17 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
         await self.comm.set_state(IRunning, RunningState(running=self._running))
         await self._publish_robotic_state()
 
+    async def _clear_current_task(self) -> None:
+        """Forget the current task and publish the state."""
+        self._task = None
+        self._project_priority = None
+        self._observation = None
+        self._task_target = None
+        self._obsnum = None
+        self._task_start = None
+        self._task_eta = None
+        await self._publish_robotic_state()
+
     async def _publish_robotic_state(self) -> None:
         """Publish IRobotic state: current task (from self._task/...), and self._next_observation
         / self._cant_run_reason as last updated by _run_thread."""
@@ -268,6 +281,7 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
             # ETA
             now = Time.now()
             eta = now + self._task.duration * u.second
+            window_end = observation.end  # scheduled end, observation.end is overwritten below
             self._task_start = now
             self._task_eta = eta
 
@@ -282,31 +296,37 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
             await self._observation_archive.update_observation(observation)
             await self._publish_robotic_state()
 
-            # run task in thread
+            # run task, abort if it exceeds its window by more than allowed_overrun
             log.info("Running task %s...", self._task.name)
+            deadline: float | None = None
+            if self._allowed_overrun is not None:
+                deadline = (window_end + self._allowed_overrun * u.second - Time.now()).to_value("second")
             try:
-                await self._task_runner.run_task(self._task, self._task_target)
+                async with asyncio.timeout(deadline) as timeout:
+                    await self._task_runner.run_task(self._task, self._task_target)
             except Exception as e:
+                if isinstance(e, TimeoutError) and timeout.expired():
+                    log.warning(
+                        "Task %s exceeded its window by more than %d s, aborted.",
+                        self._task.name,
+                        self._allowed_overrun,
+                    )
+                    state = ObservationState.ABORTED
                 # a PyobsError is an expected/domain failure (e.g. acquisition out of tolerance) --
                 # quiet INFO line, no traceback. Anything else is unexpected and needs a full
                 # traceback to debug. e.log() also skips re-logging if some deeper layer (e.g. the
                 # module's own execute()) already logged this same exception.
-                if isinstance(e, exc.PyobsError):
-                    e.log(log, "INFO", f"Task {self._task.name} failed: {e}")
                 else:
-                    log.exception("Task %s failed.", self._task.name)
+                    if isinstance(e, exc.PyobsError):
+                        e.log(log, "INFO", f"Task {self._task.name} failed: {e}")
+                    else:
+                        log.exception("Task %s failed.", self._task.name)
+                    state = ObservationState.FAILED
                 observation.end = Time.now()
-                observation.state = ObservationState.FAILED
+                observation.state = state
                 await self._observation_archive.update_observation(observation)
                 await self.comm.send_event(TaskFailedEvent(name=self._task.name, id=self._task.id, obsnum=self._obsnum))
-                self._task = None
-                self._project_priority = None
-                self._observation = None
-                self._task_target = None
-                self._obsnum = None
-                self._task_start = None
-                self._task_eta = None
-                await self._publish_robotic_state()
+                await self._clear_current_task()
                 continue
 
             # send event and change state
@@ -317,14 +337,7 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
 
             # finish
             log.info("Finished task %s.", self._task.name)
-            self._task = None
-            self._project_priority = None
-            self._observation = None
-            self._task_target = None
-            self._obsnum = None
-            self._task_start = None
-            self._task_eta = None
-            await self._publish_robotic_state()
+            await self._clear_current_task()
 
             # sleep?
             await asyncio.sleep(self._after_task_sleep)

{pyobs_core-2.20.0 → pyobs_core-2.22.0}/pyobs/modules/robotic/pointing.py

@@ -122,7 +122,7 @@ class PointingSeries(Module, IAutonomous):
 
             return True
 
-        except (ValueError, exc.RemoteError):
+        except (ValueError, exc.PyobsError):
             log.info("Could not acquire position.")
             return False