pyobs-core 2.0.0.dev89__tar.gz → 2.0.0.dev91__tar.gz

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/PKG-INFO

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

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/application.py

@@ -260,7 +260,16 @@ class Application:
                 # stem-mismatch check below. Give it the config file's own stem instead.
                 cfg = {**cfg, "comm": {"class": f"{DummyComm.__module__}.{DummyComm.__name__}", "name": config_stem}}
             log.info("Creating module from class %s...", klass.__name__)
-            self._module = get_object(cfg, Module)
+            try:
+                self._module = get_object(cfg, Module)
+            except Exception:
+                # The module-creation failure (bad kwargs, broken __init__ chain, ...) is
+                # otherwise only visible as an uncaught traceback on stderr -- which is
+                # /dev/null for daemonized modules (--pid-file, as started by pyobsd /
+                # pyobs-web-admin), so it silently vanishes from all logs. Record it through
+                # the configured handlers (file/journald) before propagating.
+                log.exception("Could not create module %s from config %s.", klass.__name__, config)
+                raise
 
             # a config file whose stem doesn't match its own module's name silently splits
             # PYOBS_MODULE log tagging in two: logging that falls through both execute()

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/mixins/weatheraware.py

@@ -84,7 +84,7 @@ class WeatherAwareMixin:
                     if not self.__weatheraware_is_error_state:
                         log.error("Telescope is in error mode, cannot park.")
                 else:
-                    log.warning("Weather is bad, shutting down.")
+                    log.info("Weather is bad, shutting down.")
                     await msi.park()
 
             # save error state

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/modules/camera/basecamera.py

@@ -524,9 +524,42 @@ class BaseCamera(
         is_top = max(top, img_top)
         is_bottom = min(top + height, img_top + img_height)
 
-        # for simplicity we allow prescan/overscan only in one dimension
-        if (left < is_left or left + width > is_right) and (top < is_top or top + height > is_bottom):
-            log.warning("BIASSEC/TRIMSEC can only be calculated with a prescan/overscan on one axis only.")
+        # prescan/overscan exists only where the window extends beyond the visible frame
+        x_ovs = img_left < left or img_left + img_width > left + width
+        y_ovs = img_top < top or img_top + img_height > top + height
+
+        # window extends beyond the visible frame on both axes: the simple calculation
+        # below only supports prescan/overscan on one axis
+        if x_ovs and y_ovs:
+            log.warning(
+                "Cannot compute BIASSEC/TRIMSEC: window %dx%d at %d,%d has prescan/overscan on both axes "
+                "(only one axis is supported).",
+                img_width,
+                img_height,
+                img_left,
+                img_top,
+            )
+            return
+
+        # window lies fully inside the visible frame: there is no prescan/overscan at all
+        if (
+            not x_ovs
+            and not y_ovs
+            and (
+                img_left > left
+                or img_left + img_width < left + width
+                or img_top > top
+                or img_top + img_height < top + height
+            )
+        ):
+            log.info(
+                "No BIASSEC/TRIMSEC: window %dx%d at %d,%d lies fully inside the visible frame "
+                "(no prescan/overscan).",
+                img_width,
+                img_height,
+                img_left,
+                img_top,
+            )
             return
 
         # comments

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/modules/camera/basevideo.py

@@ -33,7 +33,7 @@ INDEX_HTML = """
     <title>Title</title>
   </head>
   <body>
-    <img src="/video.mjpg" width="100%">
+    <img src="video.mjpg" width="100%">
   </body>
 </html>
 

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/modules/image/imagewatcher.py

@@ -29,6 +29,12 @@ class ImageWatcher(Module):
 
     Watches a path for new files and stores them in all given destinations. Only if all operations were successful,
     the file is deleted.
+
+    New files are not processed immediately, but only after a wait time (``wait_time``) has passed since they were
+    detected. This is mainly to make sure the file is fully written before it is read: while the inotify watcher
+    only reports files after they have been closed for writing (``CLOSE_WRITE``), the polling watcher and the
+    initial scan in ``open()`` can see a file while its write is still in progress. The same wait time is also
+    used to delay re-processing of files whose destination copy failed (see ``_worker``).
     """
 
     __module__ = "pyobs.modules.image"
@@ -50,7 +56,9 @@ class ImageWatcher(Module):
             destinations: Filename patterns for destinations.
             poll: If True, watchpath is polled instead of watched by inotify.
             poll_interval: Interval for polling in seconds, if poll is True.
-            wait_time: Time in seconds between adding file to list and processing it.
+            wait_time: Time in seconds between adding a file to the list and processing it. Gives a file that is
+                still being written time to finish (relevant for poll mode and the initial scan) and spaces out
+                re-queued files after failed destination copies.
         """
         Module.__init__(self, **kwargs)
 

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/robotic/storage/backend/observationarchive.py

@@ -32,6 +32,7 @@ class BackendObservationArchive(ObservationArchive):
         self._mode = mode
         self._aiohttp_session: aiohttp.ClientSession | None = None
         self._last_update: Time | None = None
+        self._last_marker: Time | None = None
         self._observations = ObservationList()
 
         if auto_update:
@@ -56,30 +57,41 @@ class BackendObservationArchive(ObservationArchive):
         return self._aiohttp_session
 
     async def _check_for_changes(self) -> None:
-        """Update schedule in background."""
+        """Update schedule in background, gated on the backend's update marker."""
 
         while True:
             try:
-                await self._update()
+                await self._poll()
             except Exception as e:
                 log.error("Failed to update observations from backend: %s", e)
             await asyncio.sleep(5)
 
+    async def _poll(self) -> None:
+        """Re-download the schedule when the backend's ``last_observation_update`` marker moved.
+
+        The marker is a DB-derived ``Max(updated_at)`` (pyobs-robotic-backend#84), truthful across
+        gunicorn workers, so it is a safe refresh gate; see ``BackendTaskArchive._poll``. The
+        content comparison in :meth:`_update` still decides whether to fire ``on_tasks_changed``.
+        """
+        last_update = await self.last_update_time()
+        if self._last_marker is None or last_update > self._last_marker:
+            await self._update()
+            self._last_marker = last_update
+
     async def _update(self) -> None:
         """Fetch the schedule from the backend and apply it if anything changed.
 
-        Re-fetches unconditionally on every poll instead of gating on the backend's
-        ``last_observation_update`` marker (per-process Django ``LocMemCache``, unreliable across
-        gunicorn workers -- see ``BackendTaskArchive``). Changes are detected by comparing full
-        observation contents via ``model_dump(use_task_id=True)``, keyed by observation ID so a
-        stable reordering of the same items is not mistaken for a change: the backend serializes
-        ``task`` as a plain FK ID, while cached copies get their ``task`` replaced by a full
-        ``Task`` when the mastermind calls ``fetch_task()``, so the ID normalization keeps both
-        sides comparable. The comparison includes ``state`` (``Observation.__eq__`` ignores it),
-        which matters for in-set transitions such as ``pending`` -> ``in_progress``; observations
-        leaving the fetched set -- e.g. ``window_expired``, which the server-side ``state``/
-        ``end_after`` filters drop -- are picked up as list shrinkage by the unconditional
-        refetch.
+        Called by :meth:`_poll` after the backend marker moved (or on the first poll). Changes are
+        detected by comparing full observation contents via ``model_dump(use_task_id=True)``,
+        keyed by observation ID so a stable reordering of the same items is not mistaken for a
+        change: the backend serializes ``task`` as a plain FK ID, while cached copies get their
+        ``task`` replaced by a full ``Task`` when the mastermind calls ``fetch_task()``, so the ID
+        normalization keeps both sides comparable. The comparison includes ``state``
+        (``Observation.__eq__`` ignores it), which matters for in-set transitions such as
+        ``pending`` -> ``in_progress``; observations leaving the fetched set -- e.g.
+        ``window_expired``, which the server-side ``state``/``end_after`` filters drop -- are
+        picked up as list shrinkage on the next marker-triggered refetch (the ``mark_window_expired``
+        sweep stamps ``updated_at``, so expiry moves the marker within one sweep interval).
         """
         observations = await self._get_schedule()
         if {o.id: o.model_dump(use_task_id=True) for o in observations} != {

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/robotic/storage/backend/taskarchive.py

@@ -28,6 +28,7 @@ class BackendTaskArchive(TaskArchive):
         self._token = token
         self._aiohttp_session: aiohttp.ClientSession | None = None
         self._last_update: Time | None = None
+        self._last_marker: Time | None = None
         self._projects: list[Project] = list()
         self._tasks: list[Task] = list()
 
@@ -53,26 +54,38 @@ class BackendTaskArchive(TaskArchive):
         return self._aiohttp_session
 
     async def _check_for_changes(self) -> None:
-        """Update tasks in background."""
+        """Update tasks in background, gated on the backend's update marker."""
         while True:
             try:
-                await self._update()
+                await self._poll()
             except Exception as e:
                 log.error("Failed to update tasks from backend: %s", e)
             await asyncio.sleep(5)
 
+    async def _poll(self) -> None:
+        """Re-download tasks/projects when the backend's ``last_task_update`` marker moved.
+
+        The marker is a DB-derived ``Max(updated_at)`` (pyobs-robotic-backend#84), truthful across
+        gunicorn workers, so it is a safe refresh gate. Without it the archive re-downloaded (and
+        re-compared) on every poll, and the content comparison misfired whenever runtime code
+        mutated a serialized task field (e.g. ``DynamicTarget.resolve()`` overwriting ``name``),
+        livelocking the scheduler. The content comparison in :meth:`_update` still decides whether
+        to fire ``on_tasks_changed``.
+        """
+        last_update = await self.last_update_time()
+        if self._last_marker is None or last_update > self._last_marker:
+            await self._update()
+            self._last_marker = last_update
+
     async def _update(self) -> None:
         """Fetch tasks/projects from the backend and apply them if anything changed.
 
-        Re-fetches unconditionally on every poll instead of gating on the backend's
-        ``last_task_update`` marker: that marker is computed from a per-process Django
-        ``LocMemCache`` and is unreliable across gunicorn workers, so gating on it let the
-        mastermind run stale tasks forever. Real changes are detected by comparing the downloaded
-        content against the cached copy. The comparison uses ``model_dump()`` rather than pydantic
-        ``==``, which also compares runtime attributes (e.g. ``Task._cant_run_reason`` set by
-        ``can_run()``) and would flag unchanged tasks as changed on every poll; it is keyed by ID
-        so that a stable reordering of the same items (e.g. an unordered backend queryset) is not
-        mistaken for a change.
+        Called by :meth:`_poll` after the backend marker moved (or on the first poll); applies the
+        download only when the content actually differs from the cached copy. The comparison uses
+        ``model_dump()`` rather than pydantic ``==``, which also compares runtime attributes (e.g.
+        ``Task._cant_run_reason`` set by ``can_run()``) and would flag unchanged tasks as changed
+        on every poll; it is keyed by ID so that a stable reordering of the same items (e.g. an
+        unordered backend queryset) is not mistaken for a change.
         """
         projects = await self._get_projects()
         tasks = await self._get_tasks()

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyobs/robotic/utils/skyflats/flatfielder.py

@@ -489,7 +489,7 @@ class FlatFielder(Object):
 
             # log and return
             if frac > self._allowed_offset_frac:
-                log.warning("Deviation from target count (%.1f%%) is larger than allowed, retrying last image...", frac)
+                log.info("Deviation from target count (%.1f%%) is larger than allowed, retrying last image...", frac)
                 return False
             else:
                 log.info("Calculated new exposure time to be %.2fs.", self._exptime)

{pyobs_core-2.0.0.dev89 → pyobs_core-2.0.0.dev91}/pyproject.toml

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