pyobs-core 2.0.2__tar.gz → 2.1.0__tar.gz

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/PKG-INFO

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

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/comm/xmpp/xmppclient.py

@@ -4,7 +4,6 @@ from typing import Any
 
 import slixmpp
 import slixmpp.xmlstream
-from slixmpp.xmlstream import StanzaBase
 
 from pyobs.comm.xmpp.xep_0009.rpc import XEP_0009
 from pyobs.comm.xmpp.xep_0009_timeout import XEP_0009_timeout
@@ -71,7 +70,6 @@ class XmppClient(slixmpp.ClientXMPP):
         self.add_event_handler("failed_auth", lambda ev: self._auth(False))
         self.add_event_handler("failed_all_auth", self.failed_all_auth)
         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
@@ -112,13 +110,6 @@ class XmppClient(slixmpp.ClientXMPP):
         """
         return self.disconnect(0.0, reason=reason)
 
-    def _filter_messages(self, stanza: StanzaBase) -> StanzaBase | None:
-        # if a user with same JID is already connected, we get a conflict
-        if '<conflict xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" />' in str(stanza):
-            self._jid_conflict = True
-            return None
-        return stanza
-
     def _stream_error(self, error: Any) -> None:
         """Called when the server sends a <stream:error/>, e.g. when this connection gets
         kicked because another session took over the same JID/resource.

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/comm/xmpp/xmppcomm.py

@@ -56,8 +56,13 @@ def _retry_delay(attempt: int, cap: float = 30.0, base: float = 1.0) -> float:
     every module reconnecting to ejabberd simultaneously after a mass restart). Fixed-interval
     retries stay in lockstep across all of them, repeatedly hammering the server at the same
     instants; jitter decorrelates that so retries spread out over time instead.
+
+    The `min(attempt, 60)` doesn't affect real backoff behavior -- with the defaults, `cap`
+    already clamps the delay from attempt 5 onward. It only exists so `2 ** attempt` can't grow
+    past what a float can hold for retry loops with no attempt limit (#824: attempt 1024 raised
+    OverflowError here and killed the retrying task).
     """
-    return random.uniform(0, min(cap, base * (2**attempt)))
+    return random.uniform(0, min(cap, base * (2 ** min(attempt, 60))))
 
 
 def _log_task_exception(task: asyncio.Task[Any]) -> None:
@@ -743,7 +748,8 @@ class XmppComm(Comm):
                 continue
             if (ev.__name__, ev.version) not in peer_sent_events:
                 continue
-            asyncio.create_task(self._subscribe_event_with_retry(module_name, ev))
+            task = asyncio.create_task(self._subscribe_event_with_retry(module_name, ev))
+            task.add_done_callback(_log_task_exception)
 
         # send event
         self._send_event_to_module(ModuleOpenedEvent(), msg["from"].username)
@@ -904,7 +910,17 @@ class XmppComm(Comm):
                     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))
+                    task = asyncio.create_task(self._subscribe_event_with_retry(peer_module, ev))
+                    task.add_done_callback(_log_task_exception)
+            elif self._module is not None:
+                # send-only declaration -- pre-create the node now, before this module announces
+                # presence, so peers reacting to it in _got_online land their subscribe on the
+                # first attempt instead of falling back to the retry loop (see #824). Sequential
+                # and awaited inside open(): each _create_node can burn up to ~90s against an
+                # unresponsive pubsub service (_safe_send's 5 x 15s timeout budget plus jittered
+                # waits between attempts), times the number of send-only events this module
+                # declares. Accepted since connect fails anyway in that scenario.
+                await self._create_node(self._event_node(self._module.name, ev))
 
         # update caps and send presence
         await self._safe_send(self.client.plugin["xep_0115"].update_caps)
@@ -939,6 +955,20 @@ class XmppComm(Comm):
             return parts[2]
         return None
 
+    async def _create_node(self, node: str) -> None:
+        """Pre-create a pubsub node so a subscriber doesn't have to wait for the first publish.
+
+        The realistic error here is <conflict/> on restart (nodes persist server-side), and a
+        permission denial should degrade gracefully to today's lazy auto-create, never block
+        startup -- so IqError is swallowed. IqTimeout is already retried inside _safe_send; if it
+        still runs out, a dead server shouldn't hang open() any longer than that existing budget,
+        so it's swallowed here too rather than propagating.
+        """
+        try:
+            await self._safe_send(self.client.plugin["xep_0060"].create_node, self._pubsub_service, node)
+        except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout) as e:
+            log.debug("Could not pre-create pubsub node %s (%s), will lazy-create on first publish.", node, e)
+
     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.
 
@@ -952,20 +982,28 @@ class XmppComm(Comm):
             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))
+        try:
+            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))
+        except Exception:
+            # an unexpected (non-IqError/IqTimeout) failure must not leave key permanently
+            # marking (peer_module, event_class) as subscribed while nothing is subscribed and
+            # nothing is retrying -- discard it so a later register_event()/_got_online()
+            # re-subscribes from scratch instead of short-circuiting on the stale key (#824).
+            self._event_subscriptions.discard(key)
+            raise
 
     def _handle_event_sync(self, msg: Any) -> None:
         """Synchronous entry point for the MatchXMLMask Callback.
@@ -1058,11 +1096,7 @@ class XmppComm(Comm):
         Args:
             method: Method to call.
             *args: Parameters for method.
-            **kwargs: Parameters for method.        except slixmpp.exceptions.IqError:
-            raise RemoteException("Could not send command.")
-        except slixmpp.exceptions.IqTimeout:
-            raise exc()
-
+            **kwargs: Parameters for method.
 
         Returns:
             Return value from method.
@@ -1302,24 +1336,40 @@ class XmppComm(Comm):
         which exits the loop into the else clause (not the break path) and returns.
         Once subscribed, fetches the current value and dispatches it.
         """
-        attempt = 0
-        while node in self._state_node_handlers:
-            try:
-                await self._safe_send(self.client.plugin["xep_0060"].subscribe, self._pubsub_service, node)
-                break
-            except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
-                attempt += 1
-                if attempt == 30:
-                    log.warning(
-                        "Still failing to subscribe to state node %s after %d attempts, will keep retrying",
-                        node,
-                        attempt,
-                    )
-                await asyncio.sleep(_retry_delay(attempt))
-        else:
-            return
-
-        # Fetch current value immediately after subscribing
+        try:
+            attempt = 0
+            while node in self._state_node_handlers:
+                try:
+                    await self._safe_send(self.client.plugin["xep_0060"].subscribe, self._pubsub_service, node)
+                    break
+                except (slixmpp.exceptions.IqError, slixmpp.exceptions.IqTimeout):
+                    attempt += 1
+                    if attempt == 30:
+                        log.warning(
+                            "Still failing to subscribe to state node %s after %d attempts, will keep retrying",
+                            node,
+                            attempt,
+                        )
+                    await asyncio.sleep(_retry_delay(attempt))
+            else:
+                return
+        except Exception:
+            # an unexpected failure in the subscribe loop itself must not leave a
+            # _state_node_handlers entry behind forever -- that would permanently short-circuit
+            # _subscribe_state (see its "already subscribed" branch) while nothing is actually
+            # subscribed and nothing is retrying (#824). A later _subscribe_state call starts a
+            # fresh subscribe from scratch instead; note it only carries the callback that
+            # triggered that fresh call, not any earlier ones -- accepted as strictly better than
+            # permanent silent loss for this catastrophic, unexpected case. Logged by the task's
+            # _log_task_exception done-callback, not here, to avoid printing the traceback twice.
+            self._state_node_handlers.pop(node, None)
+            raise
+
+        # Fetch current value immediately after subscribing. Deliberately outside the block
+        # above: a bad payload (_xml_to_dataclass) or a raising callback here must not be treated
+        # as a failed subscription -- the server-side subscription is live either way, so
+        # discarding the handler would just recreate #824's permanent-silent-loss failure via a
+        # different trigger while making it look like a subscribe failure.
         try:
             result = await self._safe_send(
                 self.client.plugin["xep_0060"].get_items, self._pubsub_service, node, max_items=1
@@ -1349,7 +1399,8 @@ class XmppComm(Comm):
             # Subscribe in a background task so _get_client() returns immediately.
             # The retry loop handles the case where the publisher hasn't created
             # the node yet (e.g. GUI connects before camera's first publish).
-            asyncio.create_task(self._subscribe_with_retry(node, interface))
+            task = asyncio.create_task(self._subscribe_with_retry(node, interface))
+            task.add_done_callback(_log_task_exception)
 
         # Initial value is fetched in _subscribe_with_retry after the subscribe IQ succeeds
 

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/events/taskfailed.py

@@ -6,6 +6,7 @@ from pyobs.events.event import Event
 class DataType(TypedDict):
     name: str
     id: Any
+    obsnum: str | None
 
 
 class TaskFailedEvent(Event):
@@ -13,15 +14,16 @@ class TaskFailedEvent(Event):
 
     __module__ = "pyobs.events"
 
-    def __init__(self, name: str, id: Any, **kwargs: Any):
+    def __init__(self, name: str, id: Any, obsnum: str | None = None, **kwargs: Any):
         """Initializes a new task failed event.
 
         Args:
-            name: Name of task that just finished
+            name: Name of task that just failed
             id: Unique identifier for task
+            obsnum: Per-night observation number of the run that just failed, e.g. "20260810-001"
         """
         Event.__init__(self)
-        self.data: DataType = {"name": name, "id": id}
+        self.data: DataType = {"name": name, "id": id, "obsnum": obsnum}
 
     @property
     def name(self) -> str:
@@ -31,5 +33,9 @@ class TaskFailedEvent(Event):
     def id(self) -> Any:
         return self.data["id"]
 
+    @property
+    def obsnum(self) -> str | None:
+        return self.data["obsnum"]
+
 
 __all__ = ["TaskFailedEvent"]

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/events/taskfinished.py

@@ -6,6 +6,7 @@ from pyobs.events.event import Event
 class DataType(TypedDict):
     name: str
     id: Any
+    obsnum: str | None
 
 
 class TaskFinishedEvent(Event):
@@ -13,15 +14,16 @@ class TaskFinishedEvent(Event):
 
     __module__ = "pyobs.events"
 
-    def __init__(self, name: str, id: Any, **kwargs: Any):
+    def __init__(self, name: str, id: Any, obsnum: str | None = None, **kwargs: Any):
         """Initializes a new task finished event.
 
         Args:
             name: Name of task that just finished
             id: Unique identifier for task
+            obsnum: Per-night observation number of the run that just finished, e.g. "20260810-001"
         """
         Event.__init__(self)
-        self.data: DataType = {"name": name, "id": id}
+        self.data: DataType = {"name": name, "id": id, "obsnum": obsnum}
 
     @property
     def name(self) -> str:
@@ -31,5 +33,9 @@ class TaskFinishedEvent(Event):
     def id(self) -> Any:
         return self.data["id"]
 
+    @property
+    def obsnum(self) -> str | None:
+        return self.data["obsnum"]
+
 
 __all__ = ["TaskFinishedEvent"]

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/events/taskstarted.py

@@ -12,6 +12,7 @@ class DataType(TypedDict):
     name: str
     id: Any
     eta: str | None
+    obsnum: str | None
 
 
 class TaskStartedEvent(Event):
@@ -19,16 +20,17 @@ class TaskStartedEvent(Event):
 
     __module__ = "pyobs.events"
 
-    def __init__(self, name: str, id: Any, eta: Time | None = None, **kwargs: Any):
+    def __init__(self, name: str, id: Any, eta: Time | None = None, obsnum: str | None = None, **kwargs: Any):
         """Initializes a new task started event.
 
         Args:
             name: Name of task that just started
             id: Unique identifier for task
             eta: Predicted ETA for when the task will finish
+            obsnum: Per-night observation number assigned to this run, e.g. "20260810-001"
         """
         Event.__init__(self)
-        self.data: DataType = {"name": name, "id": id, "eta": None if eta is None else eta.isot}
+        self.data: DataType = {"name": name, "id": id, "eta": None if eta is None else eta.isot, "obsnum": obsnum}
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> Event:
@@ -49,8 +51,11 @@ class TaskStartedEvent(Event):
         if "eta" in d and isinstance(d["eta"], str):
             eta = Time(d["eta"])
 
+        # get obsnum
+        obsnum: str | None = d["obsnum"] if isinstance(d.get("obsnum"), str) else None
+
         # return object
-        return TaskStartedEvent(name=name, id=id, eta=eta)
+        return TaskStartedEvent(name=name, id=id, eta=eta, obsnum=obsnum)
 
     @property
     def name(self) -> str:
@@ -66,5 +71,9 @@ class TaskStartedEvent(Event):
 
         return Time(self.data["eta"]) if self.data["eta"] is not None else None
 
+    @property
+    def obsnum(self) -> str | None:
+        return self.data["obsnum"]
+
 
 __all__ = ["TaskStartedEvent"]

pyobs_core-2.1.0/pyobs/interfaces/IRobotic.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from abc import ABCMeta
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from ..utils.time import Time
+from .IStartStop import IStartStop
+
+if TYPE_CHECKING:
+    from ..robotic.observation import Observation
+
+
+@dataclass
+class RoboticTask:
+    id: Any
+    name: str
+    target: str | None = None  # target name, resolved if available
+    start: Time | None = None  # planned start (next) / actual start (current)
+    end: Time | None = None  # planned end / ETA
+    obsnum: str | None = None  # "20260810-001" once assigned by the executor
+    # ObservationState value (e.g. "in_progress"), kept as a plain str rather than
+    # pyobs.robotic.observation.ObservationState: pyobs.interfaces must not depend on
+    # pyobs.robotic (which itself depends on pyobs.interfaces), or module import order decides
+    # whether it works.
+    state: str | None = None
+    priority: float | None = None
+
+    @classmethod
+    def from_observation(cls, observation: Observation) -> RoboticTask:
+        """Build a wire-sized task summary from a full `Observation` record."""
+        return cls(
+            id=observation.task.id,
+            name=observation.task.name,
+            target=observation.target.name if observation.target is not None else None,
+            start=Time(observation.start),
+            end=Time(observation.end),
+            obsnum=observation.obsnum,
+            state=observation.state.value,
+            priority=observation.priority,
+        )
+
+
+@dataclass
+class RoboticState:
+    current: RoboticTask | None = None
+    next: RoboticTask | None = None  # immediate next observation to run
+    cant_run_reason: str | None = None  # from TaskRunner.cant_run_reason(), for `next`
+    time: Time = field(default_factory=Time.now)
+
+
+class IRobotic(IStartStop, metaclass=ABCMeta):
+    """The module executes a schedule of tasks (e.g. Mastermind)."""
+
+    __module__ = "pyobs.interfaces"
+
+    state = RoboticState
+
+
+__all__ = ["IRobotic", "RoboticTask", "RoboticState"]

pyobs_core-2.1.0/pyobs/interfaces/IRoboticScheduler.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..utils.time import Time
+from .IRobotic import RoboticTask
+from .IStartStop import IStartStop
+
+
+@dataclass
+class SchedulerState:
+    last_reschedule: Time | None = None
+    time: Time = field(default_factory=Time.now)
+
+
+class IRoboticScheduler(IStartStop, metaclass=ABCMeta):
+    """The module plans a schedule of tasks for an IRobotic executor to run (e.g. Scheduler)."""
+
+    __module__ = "pyobs.interfaces"
+
+    state = SchedulerState
+
+    @abstractmethod
+    async def get_schedule(self, limit: int = 20, **kwargs: Any) -> list[RoboticTask]:
+        """Return the upcoming (pending/in-progress) schedule, most imminent first.
+
+        Args:
+            limit: Maximum number of entries to return. The implementation also enforces its
+                own hard ceiling regardless of what's requested here, so the full schedule
+                never has to go over the wire.
+
+        Returns:
+            Up to `limit` scheduled tasks.
+        """
+        ...
+
+
+__all__ = ["IRoboticScheduler", "SchedulerState"]

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/interfaces/__init__.py

@@ -52,6 +52,8 @@ from .IPointingOrbitalElements import IPointingOrbitalElements, OrbitalElements
 from .IPointingRaDec import IPointingRaDec, RaDecState
 from .IPointingSeries import IPointingSeries
 from .IReady import IReady, ReadyState
+from .IRobotic import IRobotic, RoboticState, RoboticTask
+from .IRoboticScheduler import IRoboticScheduler, SchedulerState
 from .IRoof import IRoof
 from .IRotation import IRotation, RotationState
 from .IRunnable import IRunnable
@@ -149,6 +151,11 @@ __all__ = [
     "IPointingSeries",
     "IReady",
     "ReadyState",
+    "IRobotic",
+    "RoboticTask",
+    "RoboticState",
+    "IRoboticScheduler",
+    "SchedulerState",
     "IRoof",
     "IRotation",
     "RotationState",

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/modules/camera/dummycamera.py

@@ -212,7 +212,9 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
                     & (sources["y_mean"] < shape[0])
                 ]
                 model = models.Moffat2D()
-                data += make_model_image(shape, model, sources, model_shape=(15, 15))
+                data += make_model_image(
+                    shape, model, sources, model_shape=(15, 15), params_map={"x_0": "x_mean", "y_0": "y_mean"}
+                )
 
         data[data > 65535] = 65535
         return data.astype(np.uint16)

{pyobs_core-2.0.2 → pyobs_core-2.1.0}/pyobs/modules/robotic/__init__.py

@@ -5,9 +5,11 @@ TODO: write doc
 
 __title__ = "Robotic mode"
 
+from .dummymastermind import DummyMastermind
+from .dummyscheduler import DummyScheduler
 from .mastermind import Mastermind
 from .pointing import PointingSeries
 from .scheduler import Scheduler
 from .scriptrunner import ScriptRunner
 
-__all__ = ["Mastermind", "PointingSeries", "Scheduler", "ScriptRunner"]
+__all__ = ["DummyMastermind", "DummyScheduler", "Mastermind", "PointingSeries", "Scheduler", "ScriptRunner"]