pyobs-core 2.3.0__tar.gz → 2.4.1__tar.gz

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/PKG-INFO

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

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/modules/image/imagewatcher.py

@@ -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:
@@ -203,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)
@@ -259,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)
@@ -266,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.3.0 → pyobs_core-2.4.1}/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"):
@@ -326,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.4.1/pyobs/robotic/instruments.py

@@ -0,0 +1,195 @@
+"""Planning-time instrument capability data sourced from pyobs-portal's `instruments` app.
+
+Plain data models mirroring the shape `InstrumentSerializer` emits
+(`pyobs_portal/instruments/serializers.py`) -- no Django import, this module only ever
+deserializes the JSON the portal API already returns. Hand-entered planning data only, never a
+live query against `ICamera`/`IBinning`/etc.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import Field
+
+from pyobs.utils.serialization import BaseModel
+
+
+class Filter(BaseModel):
+    """A single filter position in a filter wheel."""
+
+    name: str
+    position: int | None = None
+    updated_at: str | None = None
+
+
+class BinningOption(BaseModel):
+    """Readout time for one binning mode of a camera."""
+
+    x: int
+    y: int
+    readout_time_s: float | None = None
+    updated_at: str | None = None
+
+
+class FilterWheelCapability(BaseModel):
+    """Planning-time capability data for one filter wheel.
+
+    `module_name` is nullable -- not every filter wheel is its own addressable module (some
+    cameras expose filter selection through the camera module itself), per pyobs-portal#142.
+    """
+
+    name: str = ""
+    module_name: str | None = None
+    filter_change_time_s: float | None = None
+    updated_at: str | None = None
+    filters: list[Filter] = Field(default_factory=list)
+
+
+class CameraCapability(BaseModel):
+    """Planning-time capability data for one camera, keyed by `module_name`."""
+
+    module_name: str
+    code: str
+    pixel_size_um: float | None = None
+    sensor_width_px: int | None = None
+    sensor_height_px: int | None = None
+    roi_min_width_px: int | None = None
+    roi_min_height_px: int | None = None
+    roi_step_px: int | None = None
+    exposure_time_min_s: float | None = None
+    exposure_time_max_s: float | None = None
+    image_types: list[str] = Field(default_factory=list)
+    updated_at: str | None = None
+    binnings: list[BinningOption] = Field(default_factory=list)
+    filter_wheels: list[FilterWheelCapability] = Field(default_factory=list)
+
+
+# First-pass placeholder distance for slew-duration estimates -- there's no "current pointing"
+# concept at estimate time, only a real slew *rate*, so this stands in for the actual
+# destination-minus-start-position distance a real estimate would need. See
+# specs/plans/2026-09-01-instrument-capability-duration-estimates.md's "Representative slew/rotate
+# distance" note; pyobs-core#858/#859 track replacing this with a real distance.
+#
+# A default, not a hardcoded constant inside estimate_slew_time_s() below: #858/#859's real
+# distances will likely differ per script (a flat-field PointingScript slew and an
+# ImagingScript/AutoFocusScript target slew aren't the same kind of move), and this keeps that
+# future per-caller distance a parameter on the estimate rather than a policy decision baked into
+# what's meant to stay a pure mirror of the portal's data.
+DEFAULT_SLEW_DISTANCE_DEG = 90.0
+
+
+class TelescopeCapability(BaseModel):
+    """Planning-time capability data for one telescope, keyed by `module_name`."""
+
+    module_name: str
+    aperture_mm: float | None = None
+    focal_length_mm: float | None = None
+    mount_type: str = ""
+    slew_rate_deg_per_s: float | None = None
+    updated_at: str | None = None
+
+    def estimate_slew_time_s(self, distance_deg: float = DEFAULT_SLEW_DISTANCE_DEG) -> float | None:
+        """First-pass slew-duration estimate: `distance_deg` divided by the real slew rate. None
+        if `slew_rate_deg_per_s` isn't declared (or isn't positive) -- callers fall back to their
+        own flat constant in that case, same as when no capability data exists at all.
+
+        `distance_deg` defaults to `DEFAULT_SLEW_DISTANCE_DEG`, the same first-pass placeholder
+        every caller uses today; a caller can pass its own once #858/#859 give it a real,
+        script-specific distance instead of this shared guess.
+        """
+        if self.slew_rate_deg_per_s is None or self.slew_rate_deg_per_s <= 0:
+            return None
+        return distance_deg / self.slew_rate_deg_per_s
+
+
+class DomeCapability(BaseModel):
+    """Planning-time capability data for one dome, keyed by `module_name`."""
+
+    module_name: str
+    rotate_rate_deg_per_s: float | None = None
+    updated_at: str | None = None
+
+
+class Instrument(BaseModel):
+    """One telescope + dome + camera(s) grouping, as returned by `GET /api/instruments/`.
+
+    Purely an organizational grouping on the portal side -- it carries no module identity of its
+    own; each device below carries its own `module_name`. `InstrumentCapabilities` is what
+    flattens these into the module-name-keyed lookups scripts actually use.
+    """
+
+    display_name: str = ""
+    notes: str = ""
+    updated_at: str | None = None
+    cameras: list[CameraCapability] = Field(default_factory=list)
+    telescope: TelescopeCapability | None = None
+    dome: DomeCapability | None = None
+
+
+class InstrumentCapabilities:
+    """Module-name-keyed view over a `GET /api/instruments/` response.
+
+    Scripts only ever need one device's capability row (by the module name they already
+    reference, e.g. `ImagingScript.camera`), never "the instrument" as a concept -- this flattens
+    the nested portal response into direct lookups once at parse time instead of every script
+    walking `instruments` and searching nested lists.
+    """
+
+    def __init__(self, instruments: list[Instrument]):
+        self.instruments = instruments
+        self._cameras: dict[str, CameraCapability] = {}
+        self._cameras_by_code: dict[str, CameraCapability] = {}
+        self._telescopes: dict[str, TelescopeCapability] = {}
+        self._domes: dict[str, DomeCapability] = {}
+        self._filter_wheels: dict[str, FilterWheelCapability] = {}
+
+        for instrument in instruments:
+            for camera in instrument.cameras:
+                self._cameras[camera.module_name] = camera
+                self._cameras_by_code[camera.code] = camera
+                for wheel in camera.filter_wheels:
+                    if wheel.module_name is not None:
+                        self._filter_wheels[wheel.module_name] = wheel
+            if instrument.telescope is not None:
+                self._telescopes[instrument.telescope.module_name] = instrument.telescope
+            if instrument.dome is not None:
+                self._domes[instrument.dome.module_name] = instrument.dome
+
+    @classmethod
+    def from_api_response(cls, data: list[dict[str, Any]]) -> InstrumentCapabilities:
+        """Parse `GET /api/instruments/`'s `results` list (already unwrapped by the caller)."""
+        return cls([Instrument.model_validate(item) for item in data])
+
+    def camera(self, module_name: str) -> CameraCapability | None:
+        """The `CameraCapability` whose own `module_name` matches, or None."""
+        return self._cameras.get(module_name)
+
+    def by_camera_code(self, code: str) -> CameraCapability | None:
+        """The `CameraCapability` with this fleet-wide physical camera code, or None."""
+        return self._cameras_by_code.get(code)
+
+    def telescope(self, module_name: str) -> TelescopeCapability | None:
+        """The `TelescopeCapability` whose own `module_name` matches, or None."""
+        return self._telescopes.get(module_name)
+
+    def dome(self, module_name: str) -> DomeCapability | None:
+        """The `DomeCapability` whose own `module_name` matches, or None."""
+        return self._domes.get(module_name)
+
+    def filter_wheel(self, module_name: str) -> FilterWheelCapability | None:
+        """The `FilterWheelCapability` whose own `module_name` matches, or None."""
+        return self._filter_wheels.get(module_name)
+
+
+__all__ = [
+    "DEFAULT_SLEW_DISTANCE_DEG",
+    "Filter",
+    "BinningOption",
+    "FilterWheelCapability",
+    "CameraCapability",
+    "TelescopeCapability",
+    "DomeCapability",
+    "Instrument",
+    "InstrumentCapabilities",
+]

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scheduler/astroplanscheduler.py

@@ -11,6 +11,7 @@ import astropy.units as u
 from astroplan import FixedTarget, ObservingBlock
 
 from pyobs.object import Object
+from pyobs.robotic.instruments import InstrumentCapabilities
 from pyobs.utils.time import Time
 
 from .targets import SiderealTarget
@@ -44,8 +45,17 @@ class AstroplanScheduler(TaskScheduler):
         self._is_running: bool = False
 
     async def schedule(
-        self, tasks: list[Task], projects: list[Project], start: Time, end: Time
+        self,
+        tasks: list[Task],
+        projects: list[Project],
+        start: Time,
+        end: Time,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> AsyncIterator[Observation]:
+        # instrument_capabilities: accepted for TaskScheduler interface consistency, unused --
+        # this scheduler reads the stored Task.duration field rather than calling
+        # estimate_duration() live (see specs/plans/2026-09-01-instrument-capability-duration-estimates.md
+        # Non-goals).
         # is lock acquired? send abort signal
         if self._lock.locked():
             await self.abort()

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scheduler/ondemandscheduler.py

@@ -10,6 +10,7 @@ import numpy as np
 from astropy.time import TimeDelta
 
 from pyobs.object import Object
+from pyobs.robotic.instruments import InstrumentCapabilities
 from pyobs.robotic.storage.observationarchive import ObservationArchive
 from pyobs.utils.time import Time
 
@@ -59,7 +60,12 @@ class OnDemandScheduler(TaskScheduler):
         self._global_constraints: list[Constraint] = [Constraint.create(self, c) for c in constraints]
 
     async def schedule(
-        self, tasks: list[Task], projects: list[Project], start: Time, end: Time
+        self,
+        tasks: list[Task],
+        projects: list[Project],
+        start: Time,
+        end: Time,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> AsyncIterator[Observation]:
         if self._observer is None:
             raise RuntimeError("No observer given.")
@@ -75,7 +81,9 @@ class OnDemandScheduler(TaskScheduler):
         data.archive.freeze()
 
         # schedule from start to end
-        async for task in self.schedule_in_interval(tasks, projects_dict, start, end, data):
+        async for task in self.schedule_in_interval(
+            tasks, projects_dict, start, end, data, instrument_capabilities=instrument_capabilities
+        ):
             # evolve archive -- night is keyed by the task's own scheduled time, not "now", since
             # a run can schedule up to schedule_range ahead into a different night (see
             # ObservationArchiveEvolution.evolve()'s docstring/comment for why)
@@ -95,6 +103,7 @@ class OnDemandScheduler(TaskScheduler):
         end: Time,
         data: DataProvider,
         step: float = 300,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> AsyncIterator[Observation]:
         time = start
         while time < end:
@@ -105,7 +114,9 @@ class OnDemandScheduler(TaskScheduler):
                 task.reset_resolved_target()
 
             # schedule first in this interval, could be one or two
-            async for scheduled_task in self.schedule_first_in_interval(tasks, projects, time, end, data):  # type: ignore[arg-type]
+            async for scheduled_task in self.schedule_first_in_interval(
+                tasks, projects, time, end, data, instrument_capabilities=instrument_capabilities  # type: ignore[arg-type]
+            ):
                 # yield it to caller
                 yield scheduled_task
 
@@ -128,44 +139,73 @@ class OnDemandScheduler(TaskScheduler):
         end: Time,
         data: DataProvider,
         step: float = 300,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> AsyncIterator[Observation]:
         # find current best task
-        task, merit = await self.find_next_best_task(tasks, projects, start, end, data)
+        task, merit = await self.find_next_best_task(
+            tasks, projects, start, end, data, instrument_capabilities=instrument_capabilities
+        )
 
         if task is not None and merit is not None:
             # check, whether there is another task within its duration that  will have a higher merit
             better_task, better_time, better_merit = await self.check_for_better_task(
-                task, projects, merit, tasks, start, end, data, step=step
+                task,
+                projects,
+                merit,
+                tasks,
+                start,
+                end,
+                data,
+                step=step,
+                instrument_capabilities=instrument_capabilities,
             )
 
             if better_task is not None and better_time is not None and better_merit is not None:
                 # can we maybe postpone the better task to run both?
                 postpone_time = await self.can_postpone_task(
-                    task, projects, better_task, better_merit, start, end, data
+                    task,
+                    projects,
+                    better_task,
+                    better_merit,
+                    start,
+                    end,
+                    data,
+                    instrument_capabilities=instrument_capabilities,
                 )
                 if postpone_time is not None:
                     # yes, we can! schedule both
-                    yield self.create_scheduled_task(task, merit, start)
-                    yield self.create_scheduled_task(better_task, better_merit, postpone_time)
+                    yield self.create_scheduled_task(
+                        task, merit, start, instrument_capabilities=instrument_capabilities
+                    )
+                    yield self.create_scheduled_task(
+                        better_task, better_merit, postpone_time, instrument_capabilities=instrument_capabilities
+                    )
                 else:
                     # just schedule better_task
-                    yield self.create_scheduled_task(better_task, better_merit, better_time)
+                    yield self.create_scheduled_task(
+                        better_task, better_merit, better_time, instrument_capabilities=instrument_capabilities
+                    )
 
                     # and find other tasks for in between, new end time is better_time
-                    async for between_task in self.schedule_in_interval(tasks, projects, start, better_time, data):
+                    async for between_task in self.schedule_in_interval(
+                        tasks, projects, start, better_time, data, instrument_capabilities=instrument_capabilities
+                    ):
                         yield between_task
 
             else:
                 # this seems to be the best task for now, schedule it
-                yield self.create_scheduled_task(task, merit, start)
+                yield self.create_scheduled_task(task, merit, start, instrument_capabilities=instrument_capabilities)
 
-    def create_scheduled_task(self, task: Task, merit: float, time: Time) -> Observation:
+    def create_scheduled_task(
+        self, task: Task, merit: float, time: Time, instrument_capabilities: InstrumentCapabilities | None = None
+    ) -> Observation:
         from pyobs.robotic import Observation
 
         return Observation(
             task=task,
             start=time,
-            end=time + TimeDelta(task.estimate_duration(time=time) * u.second),
+            end=time
+            + TimeDelta(task.estimate_duration(time=time, instrument_capabilities=instrument_capabilities) * u.second),
             priority=merit,
             target=task.target,
         )
@@ -213,7 +253,13 @@ class OnDemandScheduler(TaskScheduler):
         return total_merit
 
     async def evaluate_constraints_and_merits(
-        self, tasks: list[Task], projects: dict[str, Project], start: Time, end: Time, data: DataProvider
+        self,
+        tasks: list[Task],
+        projects: dict[str, Project],
+        start: Time,
+        end: Time,
+        data: DataProvider,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> list[float]:
         # evaluate all merit functions at given time
         merits: list[float] = []
@@ -230,7 +276,13 @@ class OnDemandScheduler(TaskScheduler):
                     # no merits? evaluate to 1
                     merit = 1.0
 
-                elif start + TimeDelta(task.estimate_duration(time=start) * u.second) > end:
+                elif (
+                    start
+                    + TimeDelta(
+                        task.estimate_duration(time=start, instrument_capabilities=instrument_capabilities) * u.second
+                    )
+                    > end
+                ):
                     # if task is too long for the given slot, we evaluate its merits to zero
                     merit = 0.0
 
@@ -255,11 +307,19 @@ class OnDemandScheduler(TaskScheduler):
         return merits
 
     async def find_next_best_task(
-        self, tasks: list[Task], projects: dict[str, Project], start: Time, end: Time, data: DataProvider
+        self,
+        tasks: list[Task],
+        projects: dict[str, Project],
+        start: Time,
+        end: Time,
+        data: DataProvider,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> tuple[Task | None, float]:
 
         # evaluate all merit functions at given time
-        merits = await run_cpu_bound(self.evaluate_constraints_and_merits, tasks, projects, start, end, data)
+        merits = await run_cpu_bound(
+            self.evaluate_constraints_and_merits, tasks, projects, start, end, data, instrument_capabilities
+        )
 
         # find max one
         idx = np.argmax(merits)
@@ -278,12 +338,17 @@ class OnDemandScheduler(TaskScheduler):
         end: Time,
         data: DataProvider,
         step: float = 300,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> tuple[Task | None, Time | None, float | None]:
         # exclude the already-selected task so it can't be picked as "better"
         other_tasks = [t for t in tasks if t is not task]
         t = start + TimeDelta(step * u.second)
-        while t < start + TimeDelta(task.estimate_duration(time=start) * u.second):
-            merits = await run_cpu_bound(self.evaluate_constraints_and_merits, other_tasks, projects, t, end, data)
+        while t < start + TimeDelta(
+            task.estimate_duration(time=start, instrument_capabilities=instrument_capabilities) * u.second
+        ):
+            merits = await run_cpu_bound(
+                self.evaluate_constraints_and_merits, other_tasks, projects, t, end, data, instrument_capabilities
+            )
             for i, m in enumerate(merits):
                 if m > merit:
                     return other_tasks[i], t, m
@@ -299,13 +364,24 @@ class OnDemandScheduler(TaskScheduler):
         start: Time,
         end: Time,
         data: DataProvider,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> Time | None:
         # new start time of better_task would be after the execution of task
-        better_start: Time = start + TimeDelta(task.estimate_duration(time=start) * u.second)
+        better_start: Time = start + TimeDelta(
+            task.estimate_duration(time=start, instrument_capabilities=instrument_capabilities) * u.second
+        )
 
         # evaluate merit of better_task at new start time
         merit = (
-            await run_cpu_bound(self.evaluate_constraints_and_merits, [better_task], projects, better_start, end, data)
+            await run_cpu_bound(
+                self.evaluate_constraints_and_merits,
+                [better_task],
+                projects,
+                better_start,
+                end,
+                data,
+                instrument_capabilities,
+            )
         )[0]
 
         # if it got better, return it, otherwise return Nones

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scheduler/taskscheduler.py

@@ -6,6 +6,7 @@ from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING
 
 from pyobs.object import Object
+from pyobs.robotic.instruments import InstrumentCapabilities
 from pyobs.utils.time import Time
 
 if TYPE_CHECKING:
@@ -19,7 +20,12 @@ class TaskScheduler(Object, metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     async def schedule(
-        self, tasks: list[Task], projects: list[Project], start: Time, end: Time
+        self,
+        tasks: list[Task],
+        projects: list[Project],
+        start: Time,
+        end: Time,
+        instrument_capabilities: InstrumentCapabilities | None = None,
     ) -> AsyncIterator[Observation]:
         # if we don't yield once here, mypy doesn't like this, see:
         # https://github.com/python/mypy/issues/5385

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scripts/calibration/darkbias.py

@@ -282,9 +282,20 @@ class DarkBiasScript(Script):
         peek_cached_science_exptimes_for_night(). Falls back to a placeholder single-series
         estimate at _FALLBACK_MATCH_EXPTIME if nothing is cached yet -- e.g. can_run() hasn't
         run for this site/night within the cache's TTL.
+
+        readout uses the camera's matching BinningOption.readout_time_s (data.instrument_capabilities)
+        when available, falling back to the flat 5.0 s fudge otherwise.
         """
-        # TODO: get a better estimate for readout overhead
         readout = 5.0
+        capabilities = data.instrument_capabilities if data is not None else None
+        camera = capabilities.camera(self.camera) if capabilities is not None else None
+        if camera is not None:
+            x, y = self.binning
+            for binning_option in camera.binnings:
+                if binning_option.x == x and binning_option.y == y and binning_option.readout_time_s is not None:
+                    readout = binning_option.readout_time_s
+                    break
+
         if self.exptimes is not None:
             return sum(self.count * (e + readout) for e in self.exptimes)
 

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scripts/calibration/pointing.py

@@ -51,8 +51,10 @@ class PointingScript(Script):
 
     def estimate_duration(self, data: TaskData | None = None, time: Time | None = None) -> float:
         """Estimate duration of slewing to the flat-field pointing."""
-        # TODO: get a better estimate for slewing
-        return 60.0
+        capabilities = data.instrument_capabilities if data is not None else None
+        telescope = capabilities.telescope(self.telescope) if capabilities is not None else None
+        slew_time = telescope.estimate_slew_time_s() if telescope is not None else None
+        return slew_time if slew_time is not None else 60.0
 
 
 __all__ = ["PointingScript"]

{pyobs_core-2.3.0 → pyobs_core-2.4.1}/pyobs/robotic/scripts/imaging/autofocus.py

@@ -90,8 +90,10 @@ class AutoFocusScript(Script):
 
     def estimate_duration(self, data: TaskData | None = None, time: Time | None = None) -> float:
         """Estimate duration of the autofocus run."""
-        # TODO: get a better estimate for slewing
-        return self.count * self.exposure_time + 60.0
+        capabilities = data.instrument_capabilities if data is not None else None
+        telescope = capabilities.telescope(self.telescope) if capabilities is not None else None
+        slew_time = telescope.estimate_slew_time_s() if telescope is not None else None
+        return self.count * self.exposure_time + (slew_time if slew_time is not None else 60.0)
 
 
 __all__ = ["AutoFocusScript"]