pyobs-core 2.13.2__tar.gz → 2.13.4__tar.gz

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/PKG-INFO

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

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/pyobs/modules/camera/basevideo.py

@@ -725,6 +725,7 @@ class BaseVideo(
             ValueError: If the crop lies completely outside the frame, or binning is larger than it.
         """
         data = record.data
+        source_dtype = data.dtype
         x0, y0 = 0, 0
         if crop is not None:
             x, y, w, h = crop
@@ -761,6 +762,9 @@ class BaseVideo(
         for key in image.header:
             meta[key] = self._json_safe(image.header[key])
         meta["DTYPE"] = data.dtype.newbyteorder("<").str
+        # binning turns integer data into float32, so a client needs the original dtype to resolve
+        # "full" cuts and the default cuts mode
+        meta["SRCDTYPE"] = source_dtype.newbyteorder("<").str
         # NAXISn alone doesn't tell a client how many axes to read (e.g. colour frames are 3D)
         meta["NAXIS"] = data.ndim
         meta["VIDFRAME"] = record.number

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/pyobs/robotic/scheduler/astroplanscheduler.py

@@ -3,12 +3,15 @@ from __future__ import annotations
 import asyncio
 import logging
 import multiprocessing as mp
+import queue
+import traceback
 from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any
 
 import astroplan
 import astropy.units as u
 from astroplan import FixedTarget, ObservingBlock
+from astropy.time import Time as AstropyTime
 
 from pyobs.object import Object
 from pyobs.robotic.instruments import InstrumentCapabilities
@@ -22,6 +25,9 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
+# (task id, start, end) of a scheduled block, as sent back from the scheduler process
+ScheduledBlock = tuple[Any, AstropyTime, AstropyTime]
+
 
 class AstroplanScheduler(TaskScheduler):
     """Scheduler based on astroplan."""
@@ -124,7 +130,8 @@ class AstroplanScheduler(TaskScheduler):
                     task.duration * u.second,
                     priority,
                     constraints=[c.to_astroplan() for c in task.constraints] if task.constraints else None,
-                    configuration={"request": task},
+                    # no task in configuration: scheduled blocks are pickled back from the worker process,
+                    # and tasks reference unpicklable comm proxies; _convert_blocks matches by name instead
                     name=task.id,
                 )
             )
@@ -134,27 +141,39 @@ class AstroplanScheduler(TaskScheduler):
 
     async def _schedule_blocks(
         self, blocks: list[ObservingBlock], start: Time, end: Time, constraints: list[Any], abort: asyncio.Event
-    ) -> list[ObservingBlock]:
+    ) -> list[ScheduledBlock]:
 
         # run actual scheduler in separate process and wait for it
-        queue_out: mp.Queue[list[ObservingBlock]] = mp.Queue()
+        queue_out: mp.Queue[tuple[str, Any]] = mp.Queue()
         p = mp.Process(target=self._schedule_process, args=(blocks, start, end, constraints, self.observer, queue_out))
         p.start()
 
-        # wait for process to finish
-        # note that the process only finishes, when the queue is empty! so we have to poll the queue first
-        # and then the process.
-        loop = asyncio.get_running_loop()
-        future = loop.run_in_executor(None, queue_out.get, True)  # type: ignore[arg-type]
-        while not future.done():
+        # wait for result, polling the queue: the process only finishes when the queue is drained, and a
+        # blocking get() would hang forever if the process dies without sending anything
+        while True:
             if abort.is_set():
                 p.kill()
                 return []
-            else:
-                await asyncio.sleep(0.1)
-        scheduled_blocks: list[ObservingBlock] = await future
+            try:
+                status, result = queue_out.get_nowait()
+                break
+            except queue.Empty:
+                pass
+            if not p.is_alive():
+                # anything put before exit has been flushed to the pipe by now
+                try:
+                    status, result = queue_out.get_nowait()
+                    break
+                except queue.Empty:
+                    raise RuntimeError(f"Scheduler process exited with code {p.exitcode} without sending a result.")
+            await asyncio.sleep(0.1)
+
+        loop = asyncio.get_running_loop()
         await loop.run_in_executor(None, p.join)
 
+        if status == "error":
+            raise RuntimeError(f"Scheduler process failed:\n{result}")
+        scheduled_blocks: list[ScheduledBlock] = result
         return scheduled_blocks
 
     @staticmethod
@@ -164,38 +183,44 @@ class AstroplanScheduler(TaskScheduler):
         end: Time,
         constraints: list[Any],
         observer: Any,
-        scheduled_blocks: mp.Queue[list[ObservingBlock]],
+        queue_out: mp.Queue[tuple[str, Any]],
     ) -> None:
-        """Actually do the scheduling, usually run in a separate process."""
+        """Actually do the scheduling, usually run in a separate process.
+
+        Only plain (name, start, end) tuples are sent back, since the result is pickled and blocks may
+        reference objects that can't be pickled.
+        """
 
         # log it
         log.info("Calculating schedule for %d schedulable block(s) starting at %s...", len(blocks), start)
 
-        # we don't need any transitions
-        transitioner = astroplan.Transitioner()
+        try:
+            # we don't need any transitions
+            transitioner = astroplan.Transitioner()
 
-        # create scheduler
-        scheduler = astroplan.PriorityScheduler(constraints, observer, transitioner=transitioner)
+            # create scheduler
+            scheduler = astroplan.PriorityScheduler(constraints, observer, transitioner=transitioner)
 
-        # run scheduler
-        logging.disable(logging.WARNING)
-        time_range = astroplan.Schedule(start, end)
-        schedule = scheduler(blocks, time_range)
-        logging.disable(logging.NOTSET)
+            # run scheduler
+            logging.disable(logging.WARNING)
+            try:
+                time_range = astroplan.Schedule(start, end)
+                schedule = scheduler(blocks, time_range)
+            finally:
+                logging.disable(logging.NOTSET)
 
-        # put scheduled blocks in queue
-        scheduled_blocks.put(schedule.scheduled_blocks)
+            # put scheduled blocks in queue
+            queue_out.put(("ok", [(b.name, b.start_time, b.end_time) for b in schedule.scheduled_blocks]))
 
-        # clean up
-        del transitioner, scheduler, schedule
+        except Exception:
+            queue_out.put(("error", traceback.format_exc()))
 
-    async def _convert_blocks(self, blocks: list[ObservingBlock], tasks: list[Task]) -> ObservationList:
+    async def _convert_blocks(self, blocks: list[ScheduledBlock], tasks: list[Task]) -> ObservationList:
         from pyobs.robotic import Observation, ObservationList
 
         scheduled_tasks = ObservationList()
-        for block in blocks:
+        for task_id, block_start, block_end in blocks:
             # find task
-            task_id = block.name
             for task in tasks:
                 if task.id == task_id:
                     break
@@ -203,9 +228,7 @@ class AstroplanScheduler(TaskScheduler):
                 raise ValueError(f"Could not find task with id '{task_id}'")
 
             # create scheduled task
-            scheduled_tasks.append(
-                Observation(task=task, start=block.start_time, end=block.end_time, target=task.target)
-            )
+            scheduled_tasks.append(Observation(task=task, start=block_start, end=block_end, target=task.target))
 
         return scheduled_tasks
 

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/pyobs/robotic/scripts/calibration/darkbias.py

@@ -250,7 +250,7 @@ class DarkBiasScript(Script):
             by_combo = await science_exptimes_for_night(self.archive, self.site, night)
             exptimes = self._flatten_matching_exptimes(by_combo)
             if not exptimes:
-                log.warning(
+                log.info(
                     "No science exptimes found for night %s at binning %s; nothing to expose.",
                     night,
                     self._binning_str(),

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/pyobs/utils/stretch.py

@@ -75,26 +75,29 @@ def downsample(data: NDArray[Any], factor: int) -> NDArray[Any]:
     return cropped.reshape(shape).mean(axis=(1, 3))
 
 
-def compute_cuts(data: NDArray[Any], params: StretchParams) -> tuple[float, float]:
+def compute_cuts(data: NDArray[Any], params: StretchParams, dtype: Any = None) -> tuple[float, float]:
     """Computes the low and high cut for the given data.
 
     Args:
         data: Image data.
         params: Stretch parameters.
+        dtype: dtype that decides the ``full`` range and the default cuts mode, if different from the
+            data's, e.g. when it was downsampled to float32 from integer data. Defaults to the data's dtype.
 
     Returns:
         Tuple of (low, high) data values.
     """
+    dtype = np.dtype(dtype) if dtype is not None else data.dtype
     cuts = params.cuts
     if cuts is None:
-        cuts = "full" if data.dtype == np.uint8 else "minmax"
+        cuts = "full" if dtype == np.uint8 else "minmax"
 
     if cuts == "manual":
         return float(params.lo), float(params.hi)  # type: ignore[arg-type]
     if cuts == "full":
-        if not np.issubdtype(data.dtype, np.integer):
+        if not np.issubdtype(dtype, np.integer):
             raise ValueError("Cuts mode 'full' needs integer data.")
-        info = np.iinfo(data.dtype)
+        info = np.iinfo(dtype)
         return float(info.min), float(info.max)
 
     sample = data[::_CUTS_SUBSAMPLE, ::_CUTS_SUBSAMPLE] if data.shape[0] > 256 else data
@@ -109,7 +112,7 @@ def compute_cuts(data: NDArray[Any], params: StretchParams) -> tuple[float, floa
     return float(low), float(high)
 
 
-def stretch_to_uint8(data: NDArray[Any], params: StretchParams | None = None) -> NDArray[np.uint8]:
+def stretch_to_uint8(data: NDArray[Any], params: StretchParams | None = None, dtype: Any = None) -> NDArray[np.uint8]:
     """Maps image data to 8 bit for display.
 
     Colour images (3D, colour as last axis) use the same cuts for all channels.
@@ -117,18 +120,22 @@ def stretch_to_uint8(data: NDArray[Any], params: StretchParams | None = None) ->
     Args:
         data: Image data.
         params: Stretch parameters, defaults if None.
+        dtype: dtype the cuts follow, if the data was already downsampled from a different one (e.g. a
+            binned raw frame that was integer data before). Defaults to the data's dtype.
 
     Returns:
         8-bit image.
     """
     params = params if params is not None else StretchParams()
+    # downsampling turns integer data into float32, the cuts follow the input
+    dtype = np.dtype(dtype) if dtype is not None else data.dtype
     data = downsample(data, params.scale)
 
     # fast path: 8-bit data with its full range and a linear stretch is already what we want
     if data.dtype == np.uint8 and params.stretch == "linear" and params.cuts in (None, "full"):
         return data
 
-    low, high = compute_cuts(data, params)
+    low, high = compute_cuts(data, params, dtype)
     span = high - low if high > low else 1.0
     x = np.clip((data.astype(np.float32) - low) / span, 0.0, 1.0)
 

{pyobs_core-2.13.2 → pyobs_core-2.13.4}/pyproject.toml

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