pyobs-core 2.0.0.dev84__tar.gz → 2.0.0.dev86__tar.gz

{pyobs_core-2.0.0.dev84 → pyobs_core-2.0.0.dev86}/PKG-INFO

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

{pyobs_core-2.0.0.dev84 → pyobs_core-2.0.0.dev86}/pyobs/comm/xmpp/xmppcomm.py

@@ -60,6 +60,21 @@ def _retry_delay(attempt: int, cap: float = 30.0, base: float = 1.0) -> float:
     return random.uniform(0, min(cap, base * (2**attempt)))
 
 
+def _log_task_exception(task: asyncio.Task[Any]) -> None:
+    """Retrieve and log a background task's exception, if it failed.
+
+    Results of asyncio.create_task() that are never awaited or callback-ed have their
+    exceptions reported by the event loop's default handler as "Task exception was never
+    retrieved" -- a noisy ERROR traceback that carries no context. Retrieving the exception
+    here turns that into a normal log line with the task's failure attached.
+    """
+    if task.cancelled():
+        return
+    exc = task.exception()
+    if exc is not None:
+        log.error("Unhandled exception in XMPP event handler task", exc_info=exc)
+
+
 # anchored at both ends -- re.match alone doesn't anchor the end, so e.g. "user@domain/res/extra"
 # would otherwise still "match" as a valid prefix
 _JID_RE = re.compile(r"([\w_\-\.]+)@([\w_\-\.]+)/([\w_\-\.]+)$")
@@ -979,7 +994,12 @@ class XmppComm(Comm):
                         for callback in callbacks:
                             callback(state_obj)
         else:
-            asyncio.create_task(self._handle_event(msg, node))
+            # Non-state notifications are handled asynchronously. Attach a done-callback so the
+            # task's exception is retrieved: without it, a failure inside _handle_event is never
+            # retrieved and asyncio reports it as "Task exception was never retrieved" (see
+            # _handle_event for the payload-less notification case that used to trigger this).
+            task = asyncio.create_task(self._handle_event(msg, node))
+            task.add_done_callback(_log_task_exception)
 
     async def _handle_event(self, msg: Any, node: str) -> None:
         """Handles an event.
@@ -994,7 +1014,16 @@ class XmppComm(Comm):
         # get body, unescape it, parse it
         # State-node messages are handled synchronously in _handle_event_sync
         # before this async task runs. By the time we get here it's a pyobs event.
-        body = json.loads(xml.sax.saxutils.unescape(msg["pubsub_event"]["items"]["item"]["payload"].text))
+        # Not every notification carries an item with a payload: retract stanzas,
+        # node purges, and nodes with deliver_payloads off all arrive payload-less.
+        # The state-node path copes via _fetch_and_dispatch_state; for events there is
+        # nothing to refetch, so just drop the notification.
+        items = msg["pubsub_event"]["items"]
+        item = items["item"] if items is not None else None
+        payload = item["payload"] if item is not None else None
+        if payload is None or payload.text is None:
+            return
+        body = json.loads(xml.sax.saxutils.unescape(payload.text))
 
         # do we have a <delay> element?
         delay = msg.xml.findall("{urn:sleekxmpp:delay}delay")

{pyobs_core-2.0.0.dev84 → pyobs_core-2.0.0.dev86}/pyobs/mixins/fitsheader.py

@@ -135,6 +135,15 @@ class FitsHeaderMixin:
             except exc.RemoteError as e:
                 log.warning("Could not fetch FITS headers from %s: %s.", client, str(e))
                 continue
+            except Exception as e:
+                # XmppComm.execute() only converts IqError/IqTimeout into RemoteError; anything
+                # else raised while making or deserializing the RPC call (e.g. a peer returning a
+                # malformed IFitsHeaderBefore/After response) escapes as a raw exception. That must
+                # not take down the whole exposure -- log and skip this peer's headers (#767).
+                log.warning(
+                    "Could not fetch FITS headers from %s: unexpected %s: %s.", client, type(e).__name__, str(e)
+                )
+                continue
 
             # add them to fits file
             if headers:

{pyobs_core-2.0.0.dev84 → pyobs_core-2.0.0.dev86}/pyobs/robotic/task.py

@@ -150,6 +150,7 @@ class Project(BaseModel):
     name: str = ""
     priority: float | None = Field(ge=0.0, le=9999.0, default=1.0)
     users: list[str] = Field(default_factory=list)
+    public: bool = False  # ingest backend `public` flag; default keeps old backends valid
 
 
 __all__ = ["Task", "TaskData", "Project"]

pyobs_core-2.0.0.dev86/pyobs/utils/http.py

@@ -0,0 +1,79 @@
+import asyncio
+import logging
+from typing import Any, cast
+
+import aiohttp
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+log = logging.getLogger(__name__)
+
+
+class InvalidResponseError(RuntimeError):
+    """Raised when the server returns an unexpected HTTP status. Carries the status and, if
+    available, the parsed JSON body, so callers can distinguish specific failure modes."""
+
+    def __init__(self, status: int, body: Any = None):
+        self.status = status
+        self.body = body
+        super().__init__(f"Invalid response from server: HTTP {status}")
+
+
+@retry(
+    retry=retry_if_exception_type((aiohttp.ClientError, asyncio.TimeoutError, RuntimeError)),
+    wait=wait_exponential(multiplier=1, min=1, max=30),
+    stop=stop_after_attempt(5),
+    before_sleep=before_sleep_log(log, logging.WARNING),
+    reraise=True,
+)
+async def http_request_with_retries(
+    session: aiohttp.ClientSession, url: str, method: str = "get", expected_status: int = 200, **kwargs: Any
+) -> dict[str, Any]:
+    async with session.request(method, url, **kwargs) as response:
+        if response.status != expected_status:
+            body = None
+            try:
+                body = await response.json()
+            except (aiohttp.ContentTypeError, ValueError):
+                pass
+            raise InvalidResponseError(response.status, body)
+        return cast(dict[str, Any], await response.json())
+
+
+async def http_request_paginated(
+    session: aiohttp.ClientSession, url: str, method: str = "get", expected_status: int = 200, **kwargs: Any
+) -> list[dict[str, Any]]:
+    """Fetches all pages of a DRF-style paginated list endpoint and returns the combined results.
+
+    If a page beyond the first becomes invalid mid-fetch (DRF's "Invalid page." 404, which can
+    happen when concurrent writes shift page boundaries on a live-growing dataset), pagination
+    stops early with whatever was already fetched instead of failing the whole request.
+    """
+    results: list[dict[str, Any]] = []
+    next_url: str | None = url
+    is_first_page = True
+    while next_url is not None:
+        try:
+            data = await http_request_with_retries(
+                session, next_url, method=method, expected_status=expected_status, **kwargs
+            )
+        except InvalidResponseError as e:
+            if (
+                not is_first_page
+                and e.status == 404
+                and isinstance(e.body, dict)
+                and e.body.get("detail") == "Invalid page."
+            ):
+                log.warning("Pagination page became invalid mid-fetch, stopping early with %d result(s).", len(results))
+                break
+            raise
+        results.extend(data["results"])
+        next_url = data.get("next")
+        kwargs = {}
+        is_first_page = False
+    return results

{pyobs_core-2.0.0.dev84 → pyobs_core-2.0.0.dev86}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.0.0.dev84"
+version = "2.0.0.dev86"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"

pyobs_core-2.0.0.dev84/pyobs/utils/http.py

@@ -1,46 +0,0 @@
-import asyncio
-import logging
-from typing import Any, cast
-
-import aiohttp
-from tenacity import (
-    before_sleep_log,
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-log = logging.getLogger(__name__)
-
-
-@retry(
-    retry=retry_if_exception_type((aiohttp.ClientError, asyncio.TimeoutError, RuntimeError)),
-    wait=wait_exponential(multiplier=1, min=1, max=30),
-    stop=stop_after_attempt(5),
-    before_sleep=before_sleep_log(log, logging.WARNING),
-    reraise=True,
-)
-async def http_request_with_retries(
-    session: aiohttp.ClientSession, url: str, method: str = "get", expected_status: int = 200, **kwargs: Any
-) -> dict[str, Any]:
-    async with session.request(method, url, **kwargs) as response:
-        if response.status != expected_status:
-            raise RuntimeError(f"Invalid response from server: HTTP {response.status}")
-        return cast(dict[str, Any], await response.json())
-
-
-async def http_request_paginated(
-    session: aiohttp.ClientSession, url: str, method: str = "get", expected_status: int = 200, **kwargs: Any
-) -> list[dict[str, Any]]:
-    """Fetches all pages of a DRF-style paginated list endpoint and returns the combined results."""
-    results: list[dict[str, Any]] = []
-    next_url: str | None = url
-    while next_url is not None:
-        data = await http_request_with_retries(
-            session, next_url, method=method, expected_status=expected_status, **kwargs
-        )
-        results.extend(data["results"])
-        next_url = data.get("next")
-        kwargs = {}
-    return results