pyobs-core 2.0.0.dev60__tar.gz → 2.0.0.dev62__tar.gz

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/PKG-INFO

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

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/mixins/fitsheader.py

@@ -277,6 +277,11 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
         self._fitsheadermixin_centre = centre
         self._fitsheadermixin_rotation = rotation
 
+        # only warn once per missing-header case, since these repeat on every single frame
+        self._fitsheadermixin_warned_cdelt = False
+        self._fitsheadermixin_warned_crpix = False
+        self._fitsheadermixin_warned_cd_matrix = False
+
     @property
     def rotation(self) -> float | None:
         return self._fitsheadermixin_rotation
@@ -322,8 +327,9 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
             hdr["CUNIT1"] = ("deg", "Units of CRVAL1, CDELT1")
             hdr["CUNIT2"] = ("deg", "Units of CRVAL2, CDELT2")
             hdr["WCSAXES"] = (2, "Number of WCS axes")
-        else:
+        elif not self._fitsheadermixin_warned_cdelt:
             log.warning("Could not calculate CDELT1/CDELT2 (DET-PIXL/TEL-FOCL/DET-BIN1/DET-BIN2 missing).")
+            self._fitsheadermixin_warned_cdelt = True
 
         # centre pixel
         if self._fitsheadermixin_centre is not None:
@@ -341,10 +347,11 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
                 off_y = v("YORGSUBF") if "YORGSUBF" in hdr else 0.0
             hdr["CRPIX1"] = ((v("DET-CPX1") - off_x) / v("DET-BIN1"), "Reference x-pixel position in binned image")
             hdr["CRPIX2"] = ((v("DET-CPX2") - off_y) / v("DET-BIN2"), "Reference y-pixel position in binned image")
-        else:
+        elif not self._fitsheadermixin_warned_crpix:
             log.warning(
                 "Could not calculate CRPIX1/CRPIX2 " "(XORGSUBF/YORGSUBF/DET-CPX1/TEL-CPX2/DET-BIN1/DET-BIN2) missing."
             )
+            self._fitsheadermixin_warned_crpix = True
         # only add all this stuff for OBJECT images
         if "IMAGETYP" not in hdr or hdr["IMAGETYP"] not in ["dark", "bias"]:
             # projection, only override if not already set
@@ -368,8 +375,9 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
                 hdr["PC1_2"] = (-sin_theta, "Partial of first axis coordinate w.r.t. y")
                 hdr["PC2_1"] = (+sin_theta, "Partial of second axis coordinate w.r.t. x")
                 hdr["PC2_2"] = (+cos_theta, "Partial of second axis coordinate w.r.t. y")
-            else:
+            elif not self._fitsheadermixin_warned_cd_matrix:
                 log.warning("Could not calculate CD matrix (rotation or CDELT1/CDELT2 missing.")
+                self._fitsheadermixin_warned_cd_matrix = True
 
 
 class SpectrumFitsHeaderMixin(FitsHeaderMixin):

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/modules/utils/httpfilecache.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hmac
 import logging
 from typing import Any
 
@@ -15,13 +16,22 @@ log = logging.getLogger(__name__)
 class HttpFileCache(Module):
     """A file cache based on a HTTP server."""
 
-    def __init__(self, port: int = 37075, cache_size: int = 25, max_file_size: int = 100, **kwargs: Any):
+    def __init__(
+        self,
+        port: int = 37075,
+        cache_size: int = 25,
+        max_file_size: int = 100,
+        token: str | None = None,
+        **kwargs: Any,
+    ):
         """Initializes file cache.
 
         Args:
             port: Port for HTTP server.
             cache_size: Size of file cache, i.e. number of files to cache.
             max_file_size: Maximum file size in MB.
+            token: Shared secret required in the "Authorization: Bearer <token>" header for
+                download/upload access. If None (default), no auth is enforced.
         """
         Module.__init__(self, **kwargs)
 
@@ -31,6 +41,7 @@ class HttpFileCache(Module):
         self._port = port
         self._cache_size = cache_size
         self._max_file_size = max_file_size * 1024 * 1024
+        self._token = token
 
         # define web server
         self._app = web.Application(client_max_size=self._max_file_size)
@@ -38,6 +49,7 @@ class HttpFileCache(Module):
             [
                 web.get("/ping", self.ping_handler),
                 web.get("/{filename}", self.download_handler),
+                web.options("/{filename}", self.options_handler),
                 web.post("/", self.upload_handler),
             ]
         )
@@ -67,6 +79,19 @@ class HttpFileCache(Module):
         """Whether the server is started."""
         return self._is_listening
 
+    def _check_auth(self, request: web.Request) -> None:
+        """Raises HTTPUnauthorized if a token is configured and the request doesn't carry it.
+
+        Args:
+            request: Request to check.
+        """
+        if self._token is None:
+            return
+        prefix = "Bearer "
+        header = request.headers.get("Authorization", "")
+        if not header.startswith(prefix) or not hmac.compare_digest(header[len(prefix) :], self._token):
+            raise web.HTTPUnauthorized()
+
     async def ping_handler(self, request: web.Request) -> web.Response:
         """Handles GET access to /ping for testing connectivity.
 
@@ -76,7 +101,24 @@ class HttpFileCache(Module):
         Returns:
             Response with a JSON status.
         """
-        return web.json_response({"status": "ok"})
+        return web.json_response({"status": "ok"}, headers={"Access-Control-Allow-Origin": "*"})
+
+    async def options_handler(self, request: web.Request) -> web.Response:
+        """Handles OPTIONS access to /{filename} for CORS preflight requests.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            Empty response with CORS headers.
+        """
+        return web.Response(
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET",
+                "Access-Control-Allow-Headers": "Authorization",
+            }
+        )
 
     async def download_handler(self, request: web.Request) -> web.Response:
         """Handles GET access to /{filename} and returns image.
@@ -87,6 +129,7 @@ class HttpFileCache(Module):
         Returns:
             Response containing image.
         """
+        self._check_auth(request)
 
         # get filename
         filename = request.match_info["filename"]
@@ -98,7 +141,7 @@ class HttpFileCache(Module):
 
         # send it
         log.info("Serving file %s.", filename)
-        return web.Response(body=data)
+        return web.Response(body=data, headers={"Access-Control-Allow-Origin": "*"})
 
     async def upload_handler(self, request: web.Request) -> web.Response:
         """Handles PUSH access to /, stores image and returns filename.
@@ -109,6 +152,7 @@ class HttpFileCache(Module):
         Returns:
             Response containing filename.
         """
+        self._check_auth(request)
 
         # read multipart data
         reader = await request.multipart()

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/robotic/storage/backend/observationarchive.py

@@ -9,7 +9,7 @@ import aiohttp
 
 from pyobs.robotic import ObservationArchive, Task, TaskArchive
 from pyobs.robotic.observation import Observation, ObservationList, ObservationState
-from pyobs.utils.http import http_request_with_retries
+from pyobs.utils.http import http_request_paginated, http_request_with_retries
 from pyobs.utils.time import Time
 
 log = logging.getLogger(__name__)
@@ -146,6 +146,9 @@ class BackendObservationArchive(ObservationArchive):
             if obs.state == "pending" and obs.start < time < obs.end:
                 if task_archive is not None:
                     await obs.fetch_task(task_archive)
+                    if obs.task is None:
+                        log.error("Could not resolve task for observation %s, skipping.", obs.id)
+                        continue
                 return obs
         else:
             return None
@@ -165,6 +168,9 @@ class BackendObservationArchive(ObservationArchive):
             if obs.state == "in_progress":
                 if task_archive is not None:
                     await obs.fetch_task(task_archive)
+                    if obs.task is None:
+                        log.error("Could not resolve task for observation %s, skipping.", obs.id)
+                        continue
                 return obs
         else:
             return None
@@ -223,8 +229,8 @@ class BackendObservationArchive(ObservationArchive):
             params["end_before"] = end_before.isot
         if end_after is not None:
             params["end_after"] = end_after.isot
-        observations = await http_request_with_retries(self._session, url, params=params)
-        return ObservationList([self.pyobs_model_validate(Observation, obs) for obs in observations["results"]])
+        observations = await http_request_paginated(self._session, url, params=params)
+        return ObservationList([self.pyobs_model_validate(Observation, obs) for obs in observations])
 
 
 __all__ = ["BackendObservationArchive"]

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/robotic/storage/backend/taskarchive.py

@@ -7,7 +7,7 @@ import aiohttp
 
 from pyobs.robotic.storage.taskarchive import TaskArchive
 from pyobs.robotic.task import Project, Task
-from pyobs.utils.http import http_request_with_retries
+from pyobs.utils.http import http_request_paginated, http_request_with_retries
 from pyobs.utils.time import Time
 
 log = logging.getLogger(__name__)
@@ -75,13 +75,13 @@ class BackendTaskArchive(TaskArchive):
 
     async def _get_projects(self) -> list[Project]:
         """Fetch projects from backend."""
-        projects = await http_request_with_retries(self._session, urljoin(self._url, "/api/projects/"))
-        return [self.pyobs_model_validate(Project, project) for project in projects["results"]]
+        projects = await http_request_paginated(self._session, urljoin(self._url, "/api/projects/"))
+        return [self.pyobs_model_validate(Project, project) for project in projects]
 
     async def _get_tasks(self) -> list[Task]:
         """Fetch tasks from backend."""
-        tasks = await http_request_with_retries(self._session, urljoin(self._url, "/api/tasks/"))
-        return [self.pyobs_model_validate(Task, task) for task in tasks["results"]]
+        tasks = await http_request_paginated(self._session, urljoin(self._url, "/api/tasks/"))
+        return [self.pyobs_model_validate(Task, task) for task in tasks]
 
     async def last_changed(self) -> Time | None:
         """Returns time when last time any tasks changed."""

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/utils/http.py

@@ -28,3 +28,19 @@ async def http_request_with_retries(
         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

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyobs/vfs/httpfile.py

@@ -23,8 +23,7 @@ class HttpFile(BufferedFile):
         mode: str = "r",
         download: str | None = None,
         upload: str | None = None,
-        username: str | None = None,
-        password: str | None = None,
+        token: str | None = None,
         verify_tls: bool = False,
         timeout: int = 30,
         **kwargs: Any,
@@ -36,8 +35,7 @@ class HttpFile(BufferedFile):
             mode: Open mode (r/w).
             download: Base URL for downloading files. If None, no read access possible.
             upload: Base URL for uploading files. If None, no write access possible.
-            username: Username for accessing the HTTP server.
-            password: Password for accessing the HTTP server.
+            token: Shared secret sent as "Authorization: Bearer <token>" to the HTTP server.
             verify_tls: Whether to verify TLS certificates.
             timeout: Timeout in seconds for uploading/downloading files.
         """
@@ -49,9 +47,7 @@ class HttpFile(BufferedFile):
         self._timeout = aiohttp.ClientTimeout(total=timeout)
 
         # auth
-        self._auth = None
-        if username is not None and password is not None:
-            self._auth = aiohttp.BasicAuth(username, password)
+        self._headers = {"Authorization": f"Bearer {token}"} if token is not None else {}
 
         # filename is not allowed to start with a / or contain ..
         if name.startswith("/") or ".." in name:
@@ -91,7 +87,7 @@ class HttpFile(BufferedFile):
 
         # do request
         async with aiohttp.ClientSession() as session:
-            async with session.get(self.url, auth=self._auth, timeout=self._timeout) as response:
+            async with session.get(self.url, headers=self._headers, timeout=self._timeout) as response:
                 # check response
                 if response.status == 200:
                     # get data and return it
@@ -165,7 +161,9 @@ class HttpFile(BufferedFile):
         async with aiohttp.ClientSession() as session:
             data = aiohttp.FormData()
             data.add_field("file", self._buffer(filename), filename=filename)
-            async with session.post(self._upload_path, auth=self._auth, data=data, timeout=self._timeout) as response:
+            async with session.post(
+                self._upload_path, headers=self._headers, data=data, timeout=self._timeout
+            ) as response:
                 if response.status == 401:
                     log.error("Wrong credentials for uploading file.")
                     raise FileNotFoundError

{pyobs_core-2.0.0.dev60 → pyobs_core-2.0.0.dev62}/pyproject.toml

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