pyobs-core 2.14.2__tar.gz → 2.16.0__tar.gz

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/PKG-INFO

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

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/comm/comm.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 import asyncio
 import functools
-import inspect
 import logging
 from collections.abc import Callable, Coroutine
 from typing import TYPE_CHECKING, Any, overload
 
-from pyobs.events import Event, LogEvent, ModuleClosedEvent
+from pyobs.events import Event, LogEvent, ModuleClosedEvent, registered_events
 from pyobs.interfaces import Interface
 from pyobs.interfaces.interface import get_registered_interface
 from pyobs.utils.enums import ModuleState
@@ -151,6 +150,10 @@ class Comm:
                 if interface.has_own_state():
                     await self.subscribe_state(client, interface, functools.partial(proxy.update_state, interface))
 
+            # a proxy without interfaces is useless and would stay stale (e.g. peer's disco#info not
+            # answered yet), so do not cache it
+            if len(interfaces) == 0:
+                return proxy
             self._proxies[client] = proxy
 
         return self._proxies[client]
@@ -416,17 +419,12 @@ class Comm:
         Returns:
             list of event classes.
         """
-        import pyobs.events
-
-        event_classes: list[type[Event]] = []
-        for cls in inspect.getmembers(pyobs.events, inspect.isclass):
-            if issubclass(cls[1], event):
-                event_classes.append(cls[1])
-        return event_classes
+        return [cls for cls in registered_events().values() if issubclass(cls, event)]
 
     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.
+        send them. Event classes derived from the given one are registered, too, but only those that have been
+        imported (and therefore registered) by now.
 
         Args:
             event_class: Class of event to register.

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/comm/xmpp/rpc.py

@@ -114,6 +114,22 @@ def fault_to_xml(exception: Exception) -> ET.Element:
     msg_elem.text = getattr(exception, "message", None) or str(exception)
     pyobs_fault.append(exc_elem)
     pyobs_fault.append(msg_elem)
+
+    # PyobsError ancestors (nearest first), so a caller that never imported the exception's own module can
+    # still raise the nearest class it knows (e.g. MotionError). PyobsError itself and UnclassifiedError carry
+    # no information. If original_type was sent above, the exception itself is already an ancestor-resolved
+    # class (second hop), which the name no longer tells, so it goes first.
+    candidates = type(exception).__mro__ if original_type else type(exception).__mro__[1:]
+    bases = [
+        c
+        for c in candidates
+        if isinstance(c, type) and issubclass(c, exc.PyobsError) and c not in (exc.PyobsError, exc.UnclassifiedError)
+    ]
+    bases_elem = ET.Element("bases")
+    for c in bases:
+        base_elem = ET.SubElement(bases_elem, "base")
+        base_elem.text = f"{c.__module__}.{c.__qualname__}"
+    pyobs_fault.append(bases_elem)
     value_elem.append(pyobs_fault)
     fault.append(value_elem)
     return fault
@@ -135,6 +151,47 @@ def xml_to_fault(fault_elem: ET.Element) -> tuple[str, str]:
     return exc_name, msg
 
 
+def xml_to_fault_bases(fault_elem: ET.Element) -> list[str]:
+    """Parse <fault> and return the qualified names of the exception's PyobsError ancestors, nearest first.
+
+    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")
+    if pyobs_fault is None:
+        return []
+    return [b.text for b in pyobs_fault.iterfind("bases/base") if b.text]
+
+
+def reconstruct_fault(name: str, message: str, bases: list[str], remote_module: str) -> exc.PyobsError:
+    """Build the exception for a received fault.
+
+    The exact class is used if it is registered here. If not (never a PyobsError, or its defining module was
+    never imported in this process), the nearest registered ancestor from `bases` is used, and failing that
+    UnclassifiedError. In both fallbacks the name survives as `original_type`.
+
+    Args:
+        name: Qualified name of the exception, as sent.
+        message: Message of the exception.
+        bases: Qualified names of its PyobsError ancestors, nearest first.
+        remote_module: Name of the module the fault came from.
+
+    Returns:
+        The exception to raise.
+    """
+    exception_class = exc.PyobsError.resolve(name)
+    if exception_class is not None:
+        # real registered type (e.g. FocusError) -- raised as itself, not wrapped
+        return exception_class(message, remote_module=remote_module)
+    for base in bases:
+        ancestor = exc.PyobsError.resolve(base)
+        if ancestor is not None and ancestor is not exc.UnclassifiedError:
+            return ancestor(message, original_type=name, remote_module=remote_module)
+    return exc.UnclassifiedError(message, original_type=name, remote_module=remote_module)
+
+
 # ---------------------------------------------------------------------------
 # RPC class
 # ---------------------------------------------------------------------------
@@ -291,14 +348,7 @@ class RPC:
         exc_name, msg = xml_to_fault(fault_elem)
 
         sender = iq["from"].node
-        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:
-            # 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)
+        exception = reconstruct_fault(exc_name, msg, xml_to_fault_bases(fault_elem), 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

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/comm/xmpp/xmppcomm.py

@@ -223,6 +223,7 @@ class XmppComm(Comm):
         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._discovery_retries: dict[str, asyncio.Task[None]] = {}
         self._warned_version_mismatches: set[tuple[str, str]] = set()
         self._user = user
         self._password = password
@@ -436,8 +437,10 @@ class XmppComm(Comm):
         self._capabilities = {}  # clear capabilities on reconnect
 
         # disconnect all clients
-        for jid in self._online_clients:
+        for jid in list(self._online_clients):
             self._jid_got_offline(jid)
+        for jid in list(self._discovery_retries):
+            self._cancel_discovery_retry(jid)
 
         if client.kicked_by_conflict:
             # another session took over our JID/resource -- reconnecting would just
@@ -508,32 +511,35 @@ class XmppComm(Comm):
         # return them from cache
         return await self._interface_cache[client]
 
-    async def _get_interfaces(self, jid: str, attempts: int = 3) -> list[str]:
+    async def _get_interfaces(self, jid: str, attempts: int = 3) -> list[str] | None:
         """Return list of interfaces for the given JID.
 
         Args:
             jid: JID to get interfaces for.
 
         Returns:
-            List of interface names or empty list, if an error occurred.
+            List of interface names, empty if the peer answered but does not implement IModule, or None
+            if disco#info itself failed (error, timeout, no or malformed answer).
         """
 
         # request features
         try:
             info = await self._safe_send(self.client.plugin["xep_0030"].get_info, jid=jid, cached=False)
-        except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
-            return []
+        except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout) as e:
+            log.warning("disco#info for %s failed (%s).", jid, _iq_failure_reason(e))
+            return None
 
         # extract pyobs interface names
         if info is None:
-            return []
+            return None
         try:
             if isinstance(info, slixmpp.stanza.iq.Iq):
                 info = info["disco_info"]
             prefix = "urn:pyobs:interface:"
             features = [i for i in info["features"] if i.startswith(prefix)]
         except TypeError:
-            raise IndexError()
+            log.warning("Malformed disco#info answer from %s.", jid)
+            return None
 
         # cache raw features for this JID, so a later version-mismatch can be diagnosed
         self._interface_features[jid] = features
@@ -563,7 +569,10 @@ class XmppComm(Comm):
                 return []
             else:
                 await asyncio.sleep(5)
-                interface_names = await self._get_interfaces(jid, attempts - 1)
+                retried = await self._get_interfaces(jid, attempts - 1)
+                if retried is None:
+                    return None
+                interface_names = retried
 
         # finished
         return interface_names
@@ -705,6 +714,55 @@ class XmppComm(Comm):
         if jid == self._jid:
             return
 
+        # try to get the peer online; if its disco#info failed, keep trying in the background, since
+        # slixmpp won't fire got_online again until the peer went offline and came back
+        if await self._process_online(msg):
+            self._cancel_discovery_retry(jid)
+        elif jid not in self._discovery_retries:
+            task = asyncio.create_task(self._retry_discovery(msg))
+            self._discovery_retries[jid] = task
+            task.add_done_callback(_log_task_exception)
+
+    def _cancel_discovery_retry(self, jid: str) -> None:
+        """Cancel a pending background disco#info retry for the given JID, if any."""
+        task = self._discovery_retries.pop(jid, None)
+        if task is not None and task is not asyncio.current_task():
+            task.cancel()
+
+    async def _retry_discovery(self, msg: Any) -> None:
+        """Repeat the disco#info of a peer that failed it, until it works or the peer is gone.
+
+        Args:
+            msg: Presence message of the peer.
+        """
+        jid = msg["from"].full
+        try:
+            attempt = 0
+            while jid not in self._online_clients:
+                attempt += 1
+                if attempt == 30:
+                    log.warning(
+                        "Still failing to get disco#info for %s after %d attempts, will keep retrying", jid, attempt
+                    )
+                await asyncio.sleep(_retry_delay(attempt))
+                if await self._process_online(msg):
+                    log.info("Got disco#info for %s after %d retries.", jid, attempt)
+                    return
+        finally:
+            if self._discovery_retries.get(jid) is asyncio.current_task():
+                del self._discovery_retries[jid]
+
+    async def _process_online(self, msg: Any) -> bool:
+        """Get interfaces of a peer that came online and register it.
+
+        Args:
+            msg: XMPP presence message.
+
+        Returns:
+            False if disco#info failed and it should be tried again, True otherwise.
+        """
+        jid = msg["from"].full
+
         # clear interface cache, just in case there is something there
         if jid in self._interface_cache:
             del self._interface_cache[jid]
@@ -715,6 +773,16 @@ class XmppComm(Comm):
         # request interfaces
         interface_names = await self._get_interfaces(jid)
 
+        # disco#info failed: fail waiting get_interfaces() calls instead of reporting "no interfaces"
+        if interface_names is None:
+            if jid not in self._discovery_retries:
+                log.warning("disco#info for %s failed, retrying in background.", jid)
+            future = self._interface_cache.pop(jid, None)
+            if future is not None and not future.done():
+                future.set_exception(IndexError(f"disco#info for {jid} failed."))
+                future.exception()  # mark as retrieved, there may be no waiter
+            return False
+
         # if no interfaces are implemented (not even IModule), quit here
         if len(interface_names) == 0:
             module = jid[: jid.index("@")]
@@ -724,7 +792,7 @@ class XmppComm(Comm):
             future = self._interface_cache.get(jid)
             if future is not None and not future.done():
                 future.set_result([])
-            return
+            return True
 
         # store interfaces — guard against a second _got_online for the same JID
         # (ejabberd may send multiple presence stanzas) racing against the first
@@ -775,6 +843,7 @@ class XmppComm(Comm):
 
         # send event
         self._send_event_to_module(ModuleOpenedEvent(), msg["from"].username)
+        return True
 
     def _fire_presence_callbacks(self, module_name: str, state: ModuleState, status: str) -> None:
         """Call every presence callback registered for a module, isolating failures.
@@ -845,6 +914,8 @@ class XmppComm(Comm):
         if jid in self._interface_cache:
             del self._interface_cache[jid]
         self._interface_features.pop(jid, None)
+        self._peer_sent_events.pop(jid, None)
+        self._cancel_discovery_retry(jid)
 
         # send event
         self._send_event_to_module(ModuleClosedEvent(), module_name)
@@ -1106,9 +1177,11 @@ class XmppComm(Comm):
         event = EventFactory.from_dict(body)
         if event is None:
             return
-        if time.time() - event.timestamp > 30:
+        age = time.time() - event.timestamp
+        if age > 30:
             # event is more than 30 seconds old, ignore it
             # we do this do avoid resent events after a reconnect
+            log.info("Dropping %s from %s, %.1f s old.", type(event).__name__, from_module, age)
             return
 
         # send it to module

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/events/__init__.py

@@ -5,7 +5,7 @@ TODO: write doc
 __title__ = "Events"
 
 from .badweather import BadWeatherEvent
-from .event import Event
+from .event import Event, EventFactory, get_registered_event, registered_events
 from .exposurestatuschanged import ExposureStatusChangedEvent
 from .filterchanged import FilterChangedEvent
 from .focusfound import FocusFoundEvent
@@ -31,6 +31,9 @@ __all__ = [
     "BadWeatherEvent",
     "ExposureStatusChangedEvent",
     "Event",
+    "EventFactory",
+    "get_registered_event",
+    "registered_events",
     "FilterChangedEvent",
     "FocusFoundEvent",
     "GoodWeatherEvent",

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/events/event.py

@@ -8,14 +8,34 @@ from typing import Any
 
 log = logging.getLogger(__name__)
 
+_REGISTRY: dict[str, type[Event]] = {}
+
 
 class Event:
-    """Base class for all events."""
+    """Base class for all events.
+
+    Every subclass is registered by its class name (the wire type and the pubsub node id only carry the
+    name), no matter where it is defined, so that plugins can define their own events. Two different classes
+    with the same name are rejected.
+    """
 
     __module__ = "pyobs.events"
     local: bool = False
     version: int = 1
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        existing = _REGISTRY.get(cls.__name__)
+        if existing is not None and (existing.__module__, existing.__qualname__) != (cls.__module__, cls.__qualname__):
+            raise TypeError(
+                f"Event name '{cls.__name__}' is already registered by "
+                f"{existing.__module__}.{existing.__qualname__}; "
+                f"choose a distinct name for {cls.__module__}.{cls.__qualname__}."
+            )
+        # same module and name: a reload or a redefinition, replace the old class
+        _REGISTRY[cls.__name__] = cls
+
     def __init__(self, **kwargs: Any):
         self.uuid = str(uuid.uuid4())
         self.timestamp = time.time()
@@ -35,9 +55,20 @@ class Event:
         return cls(**d)
 
 
-class EventFactory:
-    packages = [__package__]
+_REGISTRY["Event"] = Event
+
 
+def get_registered_event(name: str) -> type[Event] | None:
+    """Return the event class registered under the given class name, or None."""
+    return _REGISTRY.get(name)
+
+
+def registered_events() -> dict[str, type[Event]]:
+    """Return a copy of all registered event classes by name, in registration order."""
+    return dict(_REGISTRY)
+
+
+class EventFactory:
     @staticmethod
     def from_dict(obj_dict: dict[str, Any]) -> Event | None:
         """Create Event from a dictionary.
@@ -49,23 +80,8 @@ class EventFactory:
             Event object containing event.
         """
 
-        # create class
-        cls: Event | None = None
-        for p in EventFactory.packages:
-            if p is None:
-                continue
-            # import package
-            parts = p.split(".")
-            pkg = __import__(parts[0])
-            for comp in parts[1:]:
-                pkg = getattr(pkg, comp)
-
-            # does it have the given type as class?
-            if hasattr(pkg, obj_dict["type"]):
-                cls = getattr(pkg, obj_dict["type"])
-                break
-
-        # not found?
+        # find class, it has to be imported (and therefore registered) in this process
+        cls = get_registered_event(obj_dict["type"])
         if cls is None:
             return None
 
@@ -84,4 +100,4 @@ class EventFactory:
             return None
 
 
-__all__ = ["Event", "EventFactory"]
+__all__ = ["Event", "EventFactory", "get_registered_event", "registered_events"]

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/interfaces/IPointingAltAz.py

@@ -35,7 +35,8 @@ class IPointingAltAz(Interface, metaclass=ABCMeta):
 
         Raises:
             NotSupportedError: If this device doesn't support Alt/Az pointing.
-            AltitudeLimitError: If the destination is below the configured altitude limit.
+            PointingLimitError: If the destination is outside the pointing limits, e.g. below the configured
+                altitude limit (AltitudeLimitError).
             MoveError: If device could not be moved.
         """
         ...

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/interfaces/IPointingRaDec.py

@@ -36,7 +36,8 @@ class IPointingRaDec(Interface, metaclass=ABCMeta):
         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.
+            PointingLimitError: If the destination is outside the pointing limits, e.g. below the configured
+                altitude limit (AltitudeLimitError).
             MoveError: If device could not be moved.
         """
         ...

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/modules/robotic/mastermind.py

@@ -63,6 +63,8 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
         self._after_task_sleep = after_task_sleep
         self._cant_run_reason: str | None = None
         self._next_observation: Observation | None = None
+        self._project_priority: float | None = None
+        self._observation: Observation | None = None
 
         # add thread func
         self.add_background_task(self._run_thread, True)
@@ -258,7 +260,9 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
 
             # task is definitely not None here
             self._task = observation.task
+            self._observation = observation
             self._task_target = observation.target
+            self._project_priority = await self._lookup_project_priority(observation.task)
             self._obsnum = await self._next_obsnum()
 
             # ETA
@@ -296,6 +300,8 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
                 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
@@ -312,6 +318,8 @@ 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
@@ -321,6 +329,18 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
             # sleep?
             await asyncio.sleep(self._after_task_sleep)
 
+    async def _lookup_project_priority(self, task: Task) -> float | None:
+        """Priority of the project of the given task, or None if it cannot be determined (no task archive, an
+        archive without projects, unknown project, project without priority). Looked up once when a task starts,
+        so that all frames of a run carry the same value."""
+        if self._task_archive is None or not task.project:
+            return None
+        try:
+            projects = await self._task_archive.get_projects()
+        except NotImplementedError:
+            return None
+        return next((p.priority for p in projects if p.code == task.project), None)
+
     async def get_fits_header_before(
         self, namespaces: list[str] | None = None, **kwargs: Any
     ) -> dict[str, FitsHeaderEntry]:
@@ -342,6 +362,24 @@ class Mastermind(Module, IAutonomous, IRobotic, IFitsHeaderBefore):
                 hdr["PROJECT"] = FitsHeaderEntry(self._task.project, "Project code")
             if self._obsnum is not None:
                 hdr["OBSNUM"] = FitsHeaderEntry(self._obsnum, "Observation number (night-obsnum)")
+
+            # what the frame was asked for: priorities and constraints of the task as it was when the run started
+            if self._task.priority is not None:
+                hdr["HIERARCH REQ PRIORITY"] = FitsHeaderEntry(float(self._task.priority), "")
+            if self._project_priority is not None:
+                hdr["HIERARCH REQ PROJECT PRIORITY"] = FitsHeaderEntry(float(self._project_priority), "")
+            if self._observation is not None and self._observation.priority is not None:
+                # the value the scheduler ranked this slot by when it planned it (merit times task priority times
+                # project priority), only set by schedulers that fill Observation.priority
+                hdr["HIERARCH REQ MERIT"] = FitsHeaderEntry(float(self._observation.priority), "plan-time rank")
+            counts: dict[type, int] = {}
+            for constraint in self._task.constraints:
+                counts[type(constraint)] = counts.get(type(constraint), 0) + 1
+                for key, entry in constraint.get_fits_headers(counts[type(constraint)]).items():
+                    if key in hdr:
+                        log.debug("Header %s already set, ignoring the one of %s.", key, type(constraint).__name__)
+                        continue
+                    hdr[key] = entry
             hdr.update(version_fits_headers(self.name))
             return hdr
         else:

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/modules/robotic/scheduler.py

@@ -230,7 +230,7 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
         log.info("Removed: %d, added: %d, changed: %d", len(removed), len(added), len(changed))
         if len(removed) == 1:
             log.info(
-                "Found 1 removed block with ID %d. Last task ID was %s, current is %s.",
+                "Found 1 removed block with ID %s. Last task ID was %s, current is %s.",
                 removed[0],
                 str(self._last_task_id),
                 str(self._current_task_id),

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/modules/telescope/basetelescope.py

@@ -79,9 +79,10 @@ class MissingObserverError(exc.MotionError):
     pass
 
 
-class AltitudeLimitError(exc.PyobsError):
+class AltitudeLimitError(exc.PointingLimitError):
     """Destination altitude is below the configured limit -- an expected, deferrable condition
-    from a scheduler's point of view, not a failure to alert on. Deliberately not a MotionError:
+    from a scheduler's point of view, not a failure to alert on. Derives from PointingLimitError, so a caller
+    that never imported this module still catches it as that. Deliberately not a MotionError:
     it's not a motion fault (nothing was attempted), so it must not count towards the module's
     repeated-motion-failure escalation (see _register_exception(exc.MotionError, ...) below) --
     picking a target below the horizon is normal, not a sign the telescope is broken."""

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/modules/weather/weather.py

@@ -20,7 +20,7 @@ from pyobs.utils.versions import version_fits_headers
 log = logging.getLogger(__name__)
 
 
-class WeatherResponseError(exc.PyobsError):
+class WeatherResponseError(exc.GeneralError):
     """The weather station's API response was malformed or incomplete (missing an expected field)
     -- plausibly transient (a flaky station/network), worth retrying, as opposed to a caller
     passing a bad station/sensor name."""

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/robotic/observation.py

@@ -45,20 +45,27 @@ class Observation(BaseModel):
     consumes it -- it is always None for the pending/in_progress states Mastermind schedules
     on, and is declared so the portal's payloads keep validating under ``extra="forbid"``."""
 
+    @property
+    def task_id(self) -> Any:
+        """Id of the task: ``task.id`` for a full ``Task``, else ``task`` itself (the portal serializes
+        it as a plain id)."""
+        return self.task.id if isinstance(self.task, Task) else self.task
+
     def __str__(self) -> str:
-        return (
-            f"Observation {self.id} of {self.task.name} (#{self.task.id}) "
-            f"from {self.start} to {self.end} [{self.state}]"
-        )
+        if isinstance(self.task, Task):
+            task = f"{self.task.name} (#{self.task.id})"
+        else:
+            task = f"#{self.task}"
+        return f"Observation {self.id} of {task} from {self.start} to {self.end} [{self.state}]"
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Observation):
-            return bool(self.task.id == other.task.id and self.start == other.start and self.end == other.end)
+            return bool(self.task_id == other.task_id and self.start == other.start and self.end == other.end)
         return super().__eq__(other)
 
     def __ne__(self, other: object) -> bool:
         if isinstance(other, Observation):
-            return bool(self.task.id != other.task.id or self.start != other.start or self.end != other.end)
+            return bool(self.task_id != other.task_id or self.start != other.start or self.end != other.end)
         return super().__ne__(other)
 
     def __lt__(self, other: object) -> bool:
@@ -107,7 +114,7 @@ class ObservationList(UserList[Observation]):  # noqa: F821
     def filter(
         self,
         state: ObservationState | None = None,
-        task_id: int | None = None,
+        task_id: Any | None = None,
         start_before: Time | None = None,
         start_after: Time | None = None,
         end_before: Time | None = None,
@@ -117,7 +124,7 @@ class ObservationList(UserList[Observation]):  # noqa: F821
         if state is not None:
             new_list = [obs for obs in new_list if obs.state == state]
         if task_id is not None:
-            new_list = [obs for obs in new_list if obs.task.id == task_id]
+            new_list = [obs for obs in new_list if obs.task_id == task_id]
         if start_before is not None:
             new_list = [obs for obs in new_list if obs.start <= start_before]
         if start_after is not None:

{pyobs_core-2.14.2 → pyobs_core-2.16.0}/pyobs/robotic/scheduler/constraints/airmassconstraint.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 import astroplan
 import numpy as np
@@ -22,6 +22,10 @@ class AirmassConstraint(Constraint):
     cost: float = 2.0
     target_dependent: bool = True
     max_airmass: float = Field(ge=1.0, le=9.9, default=1.3)
+    req_token: ClassVar[str | None] = "AIRMASS"
+
+    def req_fields(self) -> dict[str, tuple[int | float | str, str]]:
+        return {"MAX": (float(self.max_airmass), "")}
 
     def to_astroplan(self) -> astroplan.AirmassConstraint:
         return astroplan.AirmassConstraint(max=self.max_airmass)