pyobs-core 2.2.0__tar.gz → 2.4.0__tar.gz

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/PKG-INFO

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

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/camera/dummycamera.py

@@ -28,9 +28,11 @@ from pyobs.interfaces import (
     IImageFormat,
     ImageFormatCapabilities,
     ImageFormatState,
+    IMotion,
     IPointingRaDec,
     ITemperatures,
     IWindow,
+    MotionState,
     RaDecState,
     SensorReading,
     TemperaturesState,
@@ -39,7 +41,7 @@ from pyobs.interfaces import (
 )
 from pyobs.modules.camera.basecamera import BaseCamera
 from pyobs.utils import exceptions as exc
-from pyobs.utils.enums import ExposureStatus, ImageFormat, ImageType
+from pyobs.utils.enums import ExposureStatus, ImageFormat, ImageType, MotionStatus
 from pyobs.utils.time import Time
 
 log = logging.getLogger(__name__)
@@ -73,6 +75,7 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
         max_mag: float = 20.0,
         seeing: float = 3.0,
         telescope: str | None = None,
+        roof: str | None = None,
         **kwargs: Any,
     ):
         """Creates a new dummy camera.
@@ -86,6 +89,10 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
             max_mag: Maximum magnitude of simulated stars.
             seeing: Seeing in arcsec FWHM.
             telescope: Name of telescope module to read pointing from (for star simulation).
+            roof: Name of roof module to read open/closed state from. When given, the sky (flat
+                flux and stars) is only simulated while the roof is not parked -- frames come
+                back dark otherwise. Fails closed: until the roof's state has been received, the
+                roof is assumed closed.
         """
         BaseCamera.__init__(self, **kwargs)
         self.add_background_task(self._cooling_thread, True)
@@ -112,6 +119,10 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
         self._telescope_module = telescope
         self._telescope_pos: SkyCoord = SkyCoord(0.0 * u.deg, 0.0 * u.deg, frame="icrs")
 
+        # roof state (updated via subscribe_state); fail closed until a state arrives
+        self._roof_module = roof
+        self._roof_open: bool = roof is None
+
         # camera state
         self._cooling = CoolingStatus()
         self._exposing = True
@@ -128,6 +139,10 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
         """Update cached telescope position from IPointingRaDec state."""
         self._telescope_pos = SkyCoord(ra=state.ra * u.deg, dec=state.dec * u.deg, frame="icrs")
 
+    def _on_roof_state(self, state: MotionState) -> None:
+        """Update cached roof open/closed state from IMotion state."""
+        self._roof_open = state.status != MotionStatus.PARKED
+
     async def open(self) -> None:
         """Opens camera."""
         # publish capabilities before super().open()
@@ -154,6 +169,10 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
         if self._telescope_module:
             await self.comm.subscribe_state(self._telescope_module, IPointingRaDec, self._on_telescope_state)
 
+        # subscribe to roof state if given
+        if self._roof_module:
+            await self.comm.subscribe_state(self._roof_module, IMotion, self._on_roof_state)
+
         # publish initial states
         await self.comm.set_state(
             ICooling,
@@ -206,7 +225,7 @@ class DummyCamera(BaseCamera, IWindow, IBinning, ICooling, IGain, IImageFormat):
 
         if exp_time > 0:
             data += make_noise_image(shape, distribution="gaussian", mean=exp_time / 1e4, stddev=exp_time / 1e5)
-            if open_shutter:
+            if open_shutter and self._roof_open:
                 sun_alt = self._sun_alt()
                 flat_counts = 30000 / np.exp(-1.28 * (4.209 + sun_alt)) * exp_time
                 data += make_noise_image(shape, distribution="gaussian", mean=flat_counts, stddev=flat_counts / 10.0)

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/focus/focusseries.py

@@ -158,7 +158,7 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
                     foc_state = focuser.get_state(IFocuser)
                     guess = foc_state.focus if foc_state is not None else 0.0
                     log.info("Using current focus of %.2fmm as initial guess.", guess)
-        except exc.PyobsError:
+        except (exc.PyobsError, ValueError):
             raise exc.FocusError("Could not fetch current focus value.")
 
         # define array of focus values to iterate
@@ -185,7 +185,7 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
                     else:
                         await focuser.set_focus(float(foc))
 
-            except exc.PyobsError:
+            except (exc.PyobsError, ValueError):
                 raise exc.FocusError("Could not set new focus value.")
 
             # do exposure

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/image/imagewatcher.py

@@ -5,7 +5,7 @@ import os
 import time
 import warnings
 from dataclasses import dataclass
-from pathlib import PurePosixPath
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from astropy.io import fits
@@ -15,6 +15,12 @@ from pyobs.utils.fits import format_filename
 
 log = logging.getLogger(__name__)
 
+# Filename suffixes whose content is attempted to be parsed as FITS (for templated destination
+# names and derived classes' process_extra/cleanup_extra hooks). Files whose names don't match
+# are still watched and copied as-is to non-templated destinations, just never handed to astropy
+# -- which is what produced the header warnings on non-FITS files.
+FITS_FILENAME_SUFFIXES = (".fits", ".fitz", ".fits.gz", ".fits.fz")
+
 
 @dataclass
 class CurrentFile:
@@ -47,6 +53,7 @@ class ImageWatcher(Module):
         poll_interval: int = 5,
         wait_time: int = 10,
         pattern: str = "*",
+        flatten: bool = True,
         **kwargs: Any,
     ):
         """Create a new image watcher.
@@ -59,6 +66,26 @@ class ImageWatcher(Module):
             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.
+            pattern: Only watch/process files matching this fnmatch pattern, checked against the full path (so
+                e.g. "*.fits" also matches files found in subdirectories). This is the single point of filtering,
+                applied uniformly in ``add_file`` regardless of watch mode -- inotify events, polling, and the
+                initial scan in ``open()`` all discover candidates first and let ``add_file`` decide, none of
+                them pre-filter by pattern before that.
+            flatten: For a non-templated destination (one without ``{placeholder}``s), whether to collapse the
+                file's path to just its basename under that destination (the historical behavior, default) or to
+                preserve its path relative to ``watchpath`` under the destination instead. Files found via
+                recursive watching or polling only keep their subdirectory structure at the destination when this
+                is False. Note this relies on the destination VFS root creating missing parent directories on
+                write (the default for e.g. ``LocalFile``) -- a destination configured to not do that would
+                repeatedly fail and re-queue any file whose relative path needs a parent directory that doesn't
+                exist yet.
+
+        Note:
+            If a directory holding a file that's already queued (added but not yet processed by ``_worker``) is
+            renamed before that happens, the worker's read of the file at its captured (pre-rename) path fails
+            and the file is dropped rather than picked up at its new location -- this is unrelated to, and not
+            covered by, the recursive-watching support for directories renamed after they no longer hold queued
+            files. Avoid renaming directories that may still hold queued/retrying files.
         """
         Module.__init__(self, **kwargs)
 
@@ -77,6 +104,7 @@ class ImageWatcher(Module):
         self._poll_interval = poll_interval
         self._wait_time = wait_time
         self._pattern = pattern
+        self._flatten = flatten
         self.current_file: CurrentFile | None = None
 
         # filename patterns
@@ -85,49 +113,58 @@ class ImageWatcher(Module):
         self._destinations = destinations
 
     async def _watch_inotify(self) -> None:
-        from asyncinotify import Inotify, Mask
+        from asyncinotify import Mask, RecursiveWatcher
 
         # get local directory
         local = await self.vfs.local_path(self._watchpath)
 
-        # Context manager to close the inotify handle after use
-        with Inotify() as inotify:
-            # add watch on local directory
-            inotify.add_watch(local, Mask.CLOSE_WRITE)
-
-            # iterate events forever
-            async for event in inotify:
-                # get filename by replacing local with watchpath
-                filename = str(event.path).replace(local, self._watchpath)
+        # recursively watch the local directory: watches are added for subdirectories as they're
+        # created or moved in, and removed as they're moved out (deletion needs no explicit
+        # removal -- the kernel invalidates the watch on its own, see the plan doc for details).
+        # A directory can also vanish between an event being received and asyncinotify acting on
+        # it (its own add_watch/rm_watch racing a concurrent delete), which raises OSError from
+        # inside the library rather than being handled there. Restart with a fresh watcher (a
+        # full re-walk) on that instead of letting it kill this task outright -- self-heals faster
+        # than falling back to the module's outer background-task restart-with-backoff.
+        while True:
+            try:
+                watcher = RecursiveWatcher(Path(local), Mask.CLOSE_WRITE)
+                async for event in watcher.watch_recursive():
+                    # get filename by replacing local with watchpath
+                    filename = str(event.path).replace(local, self._watchpath)
 
-                # add file
-                await self.add_file(filename)
+                    # add file
+                    await self.add_file(filename)
+            except OSError as e:
+                log.warning("Inotify watch error (directory likely vanished mid-scan), restarting watch: %s", e)
 
     async def _watch_poll(self) -> None:
-        # init list
-        files = set(await self.vfs.listdir(self._watchpath))
+        # init list (recursive, so subdirectories are picked up too; unfiltered by pattern here --
+        # add_file is the single point of pattern filtering, same as inotify mode)
+        files = set(await self.vfs.find(self._watchpath, "*"))
 
         # run forever
-        path = PurePosixPath(self._watchpath)
         while True:
+            await asyncio.sleep(self._poll_interval)
+
             # get new list
-            new_files = await self.vfs.listdir(self._watchpath)
+            new_files = set(await self.vfs.find(self._watchpath, "*"))
 
             # find all new files and add them
-            for f in new_files:
-                if f not in files:
-                    print(str(path / f))
-                    await self.add_file(str(path / f))
+            for f in new_files - files:
+                await self.add_file(os.path.join(self._watchpath, f))
 
             # store new list
-            files = set(new_files)
+            files = new_files
 
     async def open(self) -> None:
         """Open image watcher."""
         await Module.open(self)
 
-        # add all files from directory to queue
-        for filename in await self.vfs.listdir(self._watchpath):
+        # add all files from directory to queue (recursive, so subdirectories are picked up too;
+        # unfiltered by pattern here -- add_file is the single point of pattern filtering, same as
+        # inotify mode)
+        for filename in await self.vfs.find(self._watchpath, "*"):
             await self.add_file(os.path.join(self._watchpath, filename))
 
     async def close(self) -> None:
@@ -172,13 +209,20 @@ class ImageWatcher(Module):
                 async with self.vfs.open_file(filename, "rb") as fd:
                     data = await fd.read()
 
-                # try to load as fits file; data may well not be a FITS file at all
-                try:
-                    with warnings.catch_warnings():
-                        warnings.simplefilter("ignore", fits.verify.VerifyWarning)
-                        fits_file = await asyncio.to_thread(fits.HDUList.fromstring, data)
-                except Exception:
-                    fits_file = None
+                # only attempt to load the file as FITS when its name suggests it is one; any
+                # other file (e.g. a raw camera binary like "w123.0") is still copied as-is to
+                # non-templated destinations, just without the parse attempt and the astropy
+                # header warnings it raises on non-FITS content. A matching name is no
+                # guarantee, though -- the data may be corrupt or truncated -- hence the
+                # try/except below.
+                fits_file = None
+                if os.path.basename(filename).lower().endswith(FITS_FILENAME_SUFFIXES):
+                    try:
+                        with warnings.catch_warnings():
+                            warnings.simplefilter("ignore", fits.verify.VerifyWarning)
+                            fits_file = await asyncio.to_thread(fits.HDUList.fromstring, data)
+                    except Exception:
+                        fits_file = None
 
                 # fill current file
                 self.current_file = CurrentFile(filename=filename, data=data, hdu_list=fits_file)
@@ -193,10 +237,15 @@ class ImageWatcher(Module):
                         if out_filename is None:
                             raise ValueError("Could not create name for file.")
 
-                    else:
+                    elif self._flatten:
                         # no formatting, so just add filename to destination
                         out_filename = os.path.join(pattern, os.path.basename(filename))
 
+                    else:
+                        # preserve the file's path relative to watchpath under the destination
+                        rel = PurePosixPath(filename).relative_to(self._watchpath)
+                        out_filename = str(PurePosixPath(pattern) / rel)
+
                     # store it
                     log.info("Storing file as %s...", out_filename)
                     self.current_file.out_filename = out_filename
@@ -223,6 +272,9 @@ class ImageWatcher(Module):
                 log.info("Removing file from watch directory...")
                 if not await self.vfs.remove(filename):
                     log.warning("Could not delete %s.", filename)
+                else:
+                    # clean up any now-empty parent directories the file left behind
+                    await self._cleanup_empty_parents(filename)
 
                 # cleanup extra
                 await self.cleanup_extra(filename)
@@ -230,6 +282,23 @@ class ImageWatcher(Module):
             except Exception:
                 log.exception("Something went wrong.")
 
+    async def _cleanup_empty_parents(self, filename: str) -> None:
+        """Remove now-empty parent directories left behind by a just-deleted file.
+
+        Walks from filename's immediate parent up towards (but excluding) watchpath, removing
+        each directory while it's empty and stopping at the first one that isn't (or otherwise
+        can't be removed) -- most commonly a directory that still holds sibling files/dirs, which
+        is the normal, expected way this loop ends. Only relevant for recursive watching
+        (watchpath itself is never removed); a flat watch directory has no subdirectories for
+        this to ever act on.
+        """
+        watchpath = PurePosixPath(self._watchpath)
+        parent = PurePosixPath(filename).parent
+        while parent != watchpath and watchpath in parent.parents:
+            if not await self.vfs.rmdir(str(parent)):
+                break
+            parent = parent.parent
+
     async def process_extra(self, filename: str) -> bool:
         """Can be overwritten by derived classes to do extra processing on files.
         All information are stored in self.current_file and can be checked against the given filename.

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/module.py

@@ -439,8 +439,8 @@ class Module(Object, IModule, IConfig):
                 caps = proxy.get_capabilities(IModule)
                 module_version = caps.version if caps is not None else ""
                 remote_location = caps.location if caps is not None else None
-        except exc.PyobsError:
-            # however this failed (transport or domain), we just skip this module
+        except (exc.PyobsError, ValueError):
+            # however this failed (transport, domain, or unresolvable peer), we just skip this module
             return True
 
         # log it

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/robotic/scheduler.py

@@ -106,13 +106,21 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
 
         # get scheduler
         self._task_archive = self.add_child_object(tasks, TaskArchive, on_tasks_changed=self._update_schedule)
-        # PortalObservationArchive declares auto_update and gates its own polling loop on it --
-        # since we already drive updates via on_tasks_changed above, that poller must stay off.
-        # Other ObservationArchive implementations (e.g. LcoObservationArchive) don't declare it at
-        # all, so it must not be injected unconditionally.
+        # PortalObservationArchive's own polling loop (gated on auto_update) is the only channel
+        # by which this process learns about observation-state changes written by *other*
+        # processes (e.g. Mastermind marking an observation IN_PROGRESS/COMPLETED) -- it must stay
+        # on, or get_schedule()/get_current_observation()/get_next_observation() never see
+        # anything beyond the empty list they're constructed with. What it must NOT do is announce
+        # every update at INFO: when *this* process is the one that just computed and posted the
+        # schedule, _schedule_worker already logs it in detail (see _log_scheduled_task below), so
+        # the poller picking up its own write ~5s later would double-log it. announce_updates=False
+        # suppresses that one-line echo while leaving auto_update's poll (and the INFO log for
+        # externally-driven changes like Mastermind's) intact. Other ObservationArchive
+        # implementations (e.g. LcoObservationArchive) don't declare either param, so injection
+        # must stay conditional, not unconditional.
         extra_schedule_kwargs: dict[str, Any] = {}
-        if _class_accepts_param(schedule, "auto_update"):
-            extra_schedule_kwargs["auto_update"] = False
+        if _class_accepts_param(schedule, "announce_updates"):
+            extra_schedule_kwargs["announce_updates"] = False
         self._schedule = self.add_child_object(schedule, ObservationArchive, **extra_schedule_kwargs)
         extra_scheduler_kwargs: dict[str, Any] = {}
         if _class_accepts_param(scheduler, "observation_archive"):
@@ -180,23 +188,38 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
         )
         log.info("Downloaded %d schedulable tasks(s).", len(tasks))
 
-        # download projects
-        self._projects = await self._task_archive.get_projects()
-
-        # compare new and old lists
+        # download projects -- keep the old list around long enough to diff against below,
+        # mirroring self._tasks (only overwritten once _need_update has been decided)
+        old_projects = self._projects
+        projects = await self._task_archive.get_projects()
+        # `updated_at` is excluded: it's a portal-side save timestamp (round-trip-only field, not
+        # scheduling-relevant), and a no-op re-save still bumps it -- comparing it in would force
+        # a reschedule on every no-op edit, not just real content changes.
+        projects_changed = {p.code: p.model_dump(exclude={"updated_at"}) for p in projects} != {
+            p.code: p.model_dump(exclude={"updated_at"}) for p in old_projects
+        }
+
+        # compare new and old lists, both by ID (removed/added) and by content (changed, same ID)
         removed, added = self._compare_task_lists(self._tasks, tasks)
+        changed = self._changed_task_ids(self._tasks, tasks)
 
         # schedule update
         self._need_update = True
 
-        # no changes?
-        if not self._trigger_on_every_update and len(removed) == 0 and len(added) == 0:
+        # no changes at all?
+        if (
+            not self._trigger_on_every_update
+            and len(removed) == 0
+            and len(added) == 0
+            and len(changed) == 0
+            and not projects_changed
+        ):
             # no need to re-schedule
             log.info("No change in list of blocks detected.")
             self._need_update = False
 
-        # has only the current block been removed?
-        log.info("Removed: %d, added: %d", len(removed), len(added))
+        # has only the current block been removed, with nothing else changed?
+        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.",
@@ -204,21 +227,20 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
                 str(self._last_task_id),
                 str(self._current_task_id),
             )
-        if len(removed) == 1 and len(added) == 0 and removed[0] == self._last_task_id:
+        if (
+            len(removed) == 1
+            and len(added) == 0
+            and len(changed) == 0
+            and not projects_changed
+            and removed[0] == self._last_task_id
+        ):
             # no need to re-schedule
             log.info("Only one removed block detected, which is the one currently running.")
             self._need_update = False
 
-        # check, if one of the removed blocks was actually in schedule
-        if len(removed) > 0 and self._need_update:
-            schedule = await self._schedule.get_schedule()
-            removed_from_schedule = [s for s in schedule if s.task.id in removed]
-            if len(removed_from_schedule) == 0:
-                log.info("Found %s tasks, but none of them was scheduled.", len(removed))
-                self._need_update = False
-
         # store blocks
         self._tasks = tasks
+        self._projects = projects
 
         # schedule update
         if self._need_update:
@@ -252,6 +274,33 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
 
         return sorted(additional1), sorted(additional2)  # type: ignore[type-var]
 
+    @staticmethod
+    def _content_dump(task: Task) -> dict[str, Any]:
+        """``task.model_dump(exclude={"updated_at"})``.
+
+        ``updated_at`` is a portal-side save timestamp, not scheduling-relevant content, and a
+        no-op re-save (e.g. an unchanged DRF PATCH) still bumps it -- leaving it in would report
+        every no-op edit as a "changed" task.
+        """
+        return task.model_dump(exclude={"updated_at"})
+
+    @classmethod
+    def _changed_task_ids(cls, tasks1: list[Task], tasks2: list[Task]) -> set[Any]:
+        """IDs present in both lists whose task content differs between them.
+
+        Comparison is via ``model_dump()`` (see :meth:`_content_dump`), not pydantic ``==``:
+        ``Task.__eq__`` also compares runtime-only ``PrivateAttr``s (e.g. ``_cant_run_reason`` set
+        by ``can_run()``, or ``_resolved_target`` set while scheduling), which would make a task
+        that has merely been scheduled/run look "changed" on the next poll. ``model_dump()``
+        excludes private attributes by construction. What's left after also dropping
+        ``updated_at`` (priority, duration, script, ...) are the fields that actually matter for
+        scheduling.
+        """
+        by_id1 = {t.id: t for t in tasks1}
+        by_id2 = {t.id: t for t in tasks2}
+        common = set(by_id1).intersection(by_id2)
+        return {i for i in common if cls._content_dump(by_id1[i]) != cls._content_dump(by_id2[i])}
+
     async def _schedule_worker(self) -> None:
         await asyncio.sleep(5)
 
@@ -285,7 +334,10 @@ class Scheduler(Module, IRunnable, IRoboticScheduler):
                     # schedule
                     scheduled_tasks = ObservationList()
                     first = True
-                    async for scheduled_task in self._scheduler.schedule(self._tasks, self._projects, start, end):
+                    instrument_capabilities = self._task_archive.get_instrument_capabilities()
+                    async for scheduled_task in self._scheduler.schedule(
+                        self._tasks, self._projects, start, end, instrument_capabilities=instrument_capabilities
+                    ):
                         # remember for later
                         scheduled_tasks.append(scheduled_task)
 

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/roof/dummyroof.py

@@ -122,7 +122,7 @@ class DummyRoof(BaseRoof, IRoof):
         await self._change_motion_status(MotionStatus.ABORTING)
 
         async with LockWithAbort(self._lock_motion, self._abort_motion):
-            await self._change_motion_status(MotionStatus.IDLE)
+            await self._change_motion_status(MotionStatus.PARKED if self._is_closed() else MotionStatus.IDLE)
 
 
 __all__ = ["DummyRoof"]

{pyobs_core-2.2.0 → pyobs_core-2.4.0}/pyobs/modules/telescope/basetelescope.py

@@ -78,9 +78,12 @@ class MissingObserverError(exc.MotionError):
     pass
 
 
-class AltitudeLimitError(exc.MotionError):
+class AltitudeLimitError(exc.PyobsError):
     """Destination altitude is below the configured limit -- an expected, deferrable condition
-    from a scheduler's point of view, not a failure to alert on."""
+    from a scheduler's point of view, not a failure to alert on. 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."""
 
     pass