pyobs-core 2.0.0.dev64__tar.gz → 2.0.0.dev66__tar.gz

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/PKG-INFO

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

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/application.py

@@ -36,7 +36,7 @@ def _disable_iers_auto_download() -> None:
     iers_conf.auto_max_age = None
     iers_conf.iers_degraded_accuracy = "warn"
 
-    log.warning(
+    log.info(
         "IERS auto-download disabled — relying on the bundled astropy-iers-data snapshot. "
         "Earth orientation/UT1-UTC accuracy may degrade for predictions far from the "
         "snapshot date."

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/modules/robotic/mastermind.py

@@ -17,6 +17,7 @@ from pyobs.robotic import (
     TaskRunner,
 )
 from pyobs.robotic.scheduler.targets import Target
+from pyobs.utils import exceptions as exc
 from pyobs.utils.time import Time
 
 log = logging.getLogger(__name__)
@@ -168,9 +169,15 @@ class Mastermind(Module, IAutonomous, IFitsHeaderBefore):
             log.info("Running task %s...", self._task.name)
             try:
                 await self._task_runner.run_task(self._task, self._task_target)
-            except Exception:
-                # something went wrong
-                log.exception("Task %s failed.", self._task.name)
+            except Exception as e:
+                # a PyobsError is an expected/domain failure (e.g. acquisition out of tolerance) --
+                # quiet INFO line, no traceback. Anything else is unexpected and needs a full
+                # traceback to debug. e.log() also skips re-logging if some deeper layer (e.g. the
+                # module's own execute()) already logged this same exception.
+                if isinstance(e, exc.PyobsError):
+                    e.log(log, "INFO", f"Task {self._task.name} failed: {e}")
+                else:
+                    log.exception("Task %s failed.", self._task.name)
                 observation.end = Time.now()
                 observation.state = ObservationState.FAILED
                 await self._observation_archive.update_observation(observation)

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/robotic/scheduler/constraints/moonilluminationconstraint.py

@@ -24,7 +24,7 @@ class MoonIlluminationConstraint(Constraint):
         return astroplan.MoonIlluminationConstraint(max=self.max_phase)
 
     async def __call__(self, time: Time, task: Task, data: DataProvider) -> bool:
-        moon_illumination = data.moon_illumination(time)
+        moon_illumination = float(data.observer.moon_illumination(time))
         return moon_illumination <= self.max_phase
 
 

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/robotic/scheduler/constraints/moonseparationconstraint.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import astroplan
+import astropy.coordinates
 import astropy.units as u
 import numpy as np
 from astropy.coordinates import SkyCoord
@@ -31,12 +32,12 @@ class MoonSeparationConstraint(Constraint):
         if task.target is None:
             return True
         coord = task.target.coordinates(time)
-        moon_separation = data.moon(time).separation(coord, origin_mismatch="ignore")  # type: ignore[unexpected-keyword]
+        moon_separation = astropy.coordinates.get_body("moon", time).separation(coord, origin_mismatch="ignore")
         return float(moon_separation.degree) >= self.min_distance
 
     async def filter_skycoord(self, time: Time, coords: SkyCoord, data: DataProvider) -> np.ndarray:
-        moon = data.moon(time)
-        separations = moon.separation(coords, origin_mismatch="ignore").deg  # type: ignore[unexpected-keyword]
+        moon = astropy.coordinates.get_body("moon", time)
+        separations = moon.separation(coords, origin_mismatch="ignore").deg
         return np.asarray(separations >= self.min_distance, dtype=np.bool_)
 
 

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/robotic/scheduler/constraints/solarelevationconstraint.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Literal
 
 import astroplan
 import astropy.units as u
+from astropy.coordinates import get_sun
 from pydantic import Field
 
 from pyobs.utils.time import Time
@@ -33,12 +34,12 @@ class SolarElevationConstraint(Constraint):
         return astroplan.AtNightConstraint(max_solar_altitude=self.max_elevation * u.deg)
 
     async def __call__(self, time: Time, task: Task, data: DataProvider) -> bool:
-        sun = data.sun_altaz(time)
+        sun = data.observer.sun_altaz(time)
         in_range = self.min_elevation <= float(sun.alt.degree) <= self.max_elevation
         if self.direction == "both":
             return in_range
         else:
-            sun_coord = data.sun(time)
+            sun_coord = get_sun(time)
             transit = data.observer.target_meridian_transit_time(time, sun_coord, which="nearest")
             midnight = data.observer.midnight(time, which="nearest")
 

pyobs_core-2.0.0.dev66/pyobs/robotic/scheduler/dataprovider.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass
+from functools import cache
+
+from astroplan import Observer
+
+from pyobs.robotic.scheduler.observationarchiveevolution import (
+    ObservationArchiveEvolution,
+)
+from pyobs.utils.time import Time
+
+
+@dataclass
+class TaskSuccess:
+    date: Time
+    night: Time
+
+
+class DataProvider:
+    """Data provider for Merit classes."""
+
+    def __init__(self, observer: Observer, archive: ObservationArchiveEvolution | None = None):
+        self.observer = observer
+        self.archive = archive if archive else ObservationArchiveEvolution(observer)
+
+    @cache
+    def last_sunset(self, time: Time) -> Time:
+        """Returns the time of the last sunset."""
+
+        # get last sunset
+        return Time(self.observer.sun_set_time(time, which="previous"))
+
+    @cache
+    def last_sunrise(self, time: Time) -> Time:
+        """Returns the time of the last sunrise."""
+
+        # get last sunset
+        return Time(self.observer.sun_rise_time(time, which="previous"))
+
+    @cache
+    def night(self, time: Time) -> datetime.date:
+        """Returns the time of the last sunset."""
+        sunset = self.last_sunset(time)
+        return sunset.to_datetime().date()
+
+
+__all__ = ["DataProvider"]

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/robotic/scheduler/observationarchiveevolution.py

@@ -21,7 +21,7 @@ class ObservationArchiveEvolution:
         self._obs_for_night: dict[datetime.date, ObservationList] = {}
         self._observer = observer
 
-    async def evolve(self, scheduled_task: Observation) -> None:
+    async def evolve(self, scheduled_task: Observation, night: datetime.date) -> None:
         from pyobs.robotic.observation import Observation, ObservationState
 
         obs = Observation(
@@ -35,7 +35,14 @@ class ObservationArchiveEvolution:
         await self.observations_for_task(scheduled_task.task)
         self._obs_for_task[scheduled_task.task.id].append(obs)
 
-        night = Time.now().night_obs(self._observer)
+        # `night` is the caller's responsibility (DataProvider.night(scheduled_task.start), see
+        # OnDemandScheduler.schedule()) rather than computed here from Time.now(): a schedule() run
+        # covers up to `schedule_range` (~24h) ahead, so "the night this task happens" can differ
+        # from "the night it is right now" when evolve() runs -- using Time.now() filed every task
+        # under whichever night was current at evolve()-time, not the night it was actually
+        # scheduled into, which a later FollowMerit/PerNightMerit lookup (keyed by the task's own
+        # time) would then miss. Also avoids redoing an uncached astropy sunset computation here
+        # when DataProvider.night() already has a cached one for this exact time.
         await self.observations_for_night(night)
         self._obs_for_night[night].append(obs)
 

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyobs/robotic/scheduler/ondemandscheduler.py

@@ -14,7 +14,6 @@ from pyobs.robotic.storage.observationarchive import ObservationArchive
 from pyobs.utils.time import Time
 
 from . import DataProvider
-from ._executor import run_cpu_bound
 from .constraints import Constraint
 from .observationarchiveevolution import ObservationArchiveEvolution
 from .taskscheduler import TaskScheduler
@@ -70,8 +69,10 @@ class OnDemandScheduler(TaskScheduler):
 
         # schedule from start to end
         async for task in self.schedule_in_interval(tasks, projects_dict, start, end, data):
-            # evolve archive
-            await data.archive.evolve(task)
+            # 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)
+            await data.archive.evolve(task, data.night(task.start))
 
             # yield to caller
             yield task
@@ -251,7 +252,7 @@ class OnDemandScheduler(TaskScheduler):
     ) -> 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 self.evaluate_constraints_and_merits(tasks, projects, start, end, data)
 
         # find max one
         idx = np.argmax(merits)
@@ -275,7 +276,7 @@ class OnDemandScheduler(TaskScheduler):
         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)
+            merits = await self.evaluate_constraints_and_merits(other_tasks, projects, t, end, data)
             for i, m in enumerate(merits):
                 if m > merit:
                     return other_tasks[i], t, m
@@ -296,9 +297,7 @@ class OnDemandScheduler(TaskScheduler):
         better_start: Time = start + TimeDelta(task.estimate_duration(time=start) * 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)
-        )[0]
+        merit = (await self.evaluate_constraints_and_merits([better_task], projects, better_start, end, data))[0]
 
         # if it got better, return it, otherwise return Nones
         if merit >= better_merit:

{pyobs_core-2.0.0.dev64 → pyobs_core-2.0.0.dev66}/pyproject.toml

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

pyobs_core-2.0.0.dev64/pyobs/robotic/scheduler/_executor.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Callable, Coroutine
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, TypeVar
-
-_T = TypeVar("_T")
-
-# single worker: evaluate_constraints_and_merits calls are always awaited sequentially by the
-# caller (never fired concurrently), and DataProvider's functools.cache is not safe under real
-# concurrent access -- one worker keeps that access serialized while still freeing the main loop.
-_executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="pyobs-scheduler")
-
-
-async def run_cpu_bound(coro_fn: Callable[..., Coroutine[Any, Any, _T]], *args: object) -> _T:
-    """Runs an async callable to completion on a dedicated worker thread, off the caller's loop.
-
-    Args:
-        coro_fn: An async callable whose body does not itself need to run on the caller's
-            event loop (no dependency on the caller's other tasks, timers, or comm state).
-        args: Positional args for coro_fn.
-    """
-    loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(_executor, lambda: asyncio.run(coro_fn(*args)))
-
-
-__all__ = ["run_cpu_bound"]

pyobs_core-2.0.0.dev64/pyobs/robotic/scheduler/dataprovider.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-from functools import cache
-
-import astropy.coordinates
-from astroplan import Observer
-from astropy.coordinates import SkyCoord
-
-from pyobs.robotic.scheduler.observationarchiveevolution import (
-    ObservationArchiveEvolution,
-)
-from pyobs.utils.time import Time
-
-
-@dataclass
-class TaskSuccess:
-    date: Time
-    night: Time
-
-
-class DataProvider:
-    """Data provider for Merit classes.
-
-    The ``@cache``d methods below are only safe to call from a single thread at a time -- they're
-    used exclusively from within the scheduler's dedicated single-worker executor
-    (`pyobs.robotic.scheduler._executor.run_cpu_bound`), never concurrently from the caller's main
-    event loop. A new `DataProvider` is created per `schedule()` call, so cache lifetime is bounded
-    to one schedule computation and never leaks stale values across runs.
-    """
-
-    def __init__(self, observer: Observer, archive: ObservationArchiveEvolution | None = None):
-        self.observer = observer
-        self.archive = archive if archive else ObservationArchiveEvolution(observer)
-
-    @cache
-    def last_sunset(self, time: Time) -> Time:
-        """Returns the time of the last sunset."""
-
-        # get last sunset
-        return Time(self.observer.sun_set_time(time, which="previous"))
-
-    @cache
-    def last_sunrise(self, time: Time) -> Time:
-        """Returns the time of the last sunrise."""
-
-        # get last sunset
-        return Time(self.observer.sun_rise_time(time, which="previous"))
-
-    @cache
-    def night(self, time: Time) -> datetime.date:
-        """Returns the time of the last sunset."""
-        sunset = self.last_sunset(time)
-        return sunset.to_datetime().date()
-
-    @cache
-    def sun(self, time: Time) -> SkyCoord:
-        """Returns the Sun's coordinates at the given time."""
-        return astropy.coordinates.get_sun(time)
-
-    @cache
-    def sun_altaz(self, time: Time) -> SkyCoord:
-        """Returns the Sun's AltAz coordinates at the given time, as seen by the observer."""
-        return self.observer.sun_altaz(time)
-
-    @cache
-    def moon(self, time: Time) -> SkyCoord:
-        """Returns the Moon's coordinates at the given time."""
-        return astropy.coordinates.get_body("moon", time)
-
-    @cache
-    def moon_illumination(self, time: Time) -> float:
-        """Returns the Moon's illumination fraction at the given time."""
-        return float(self.observer.moon_illumination(time))
-
-
-__all__ = ["DataProvider"]