pyobs-core 2.0.0.dev24__tar.gz → 2.0.0.dev27__tar.gz

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/PKG-INFO

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

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/images/image.py

@@ -13,7 +13,7 @@ from astropy.table import Table
 from numpy.typing import NDArray
 
 import pyobs.utils.exceptions as exc
-from pyobs.utils.fits import FilenameFormatter
+from pyobs.utils.fits import FilenameFormatter, parse_section_bounds
 
 MetaClass = TypeVar("MetaClass")
 
@@ -378,6 +378,46 @@ class Image:
             unit="adu",
         )
 
+    def trim(self) -> Image:
+        """Return a copy of this image cropped to its TRIMSEC header, if present.
+
+        If no TRIMSEC is set, returns an unmodified copy. CRPIX1/CRPIX2 are shifted to
+        account for the new origin if present. TRIMSEC/DATASEC/BIASSEC are removed from
+        the result's header, since none remain valid coordinates into the trimmed data.
+
+        Raises:
+            ValueError: If TRIMSEC is malformed, or a catalog is already attached (its
+                pixel coordinates would silently go stale against the trimmed frame).
+        """
+
+        if self._catalog is not None:
+            raise ValueError("Cannot trim an image with an attached catalog.")
+
+        bounds = parse_section_bounds(self._header, "TRIMSEC")
+        trimmed = self.copy()
+        if bounds is None:
+            return trimmed
+
+        x0, x1, y0, y1 = bounds
+        trimmed._data = None if self._data is None else self._data[y0:y1, x0:x1]
+        trimmed._mask = None if self._mask is None else self._mask[y0:y1, x0:x1]
+        trimmed._uncertainty = None if self._uncertainty is None else self._uncertainty[y0:y1, x0:x1]
+
+        if trimmed._data is not None:
+            trimmed._header["NAXIS1"] = trimmed._data.shape[1]
+            trimmed._header["NAXIS2"] = trimmed._data.shape[0]
+
+        if "CRPIX1" in trimmed._header:
+            trimmed._header["CRPIX1"] -= x0
+        if "CRPIX2" in trimmed._header:
+            trimmed._header["CRPIX2"] -= y0
+
+        for keyword in ("TRIMSEC", "DATASEC", "BIASSEC"):
+            if keyword in trimmed._header:
+                del trimmed._header[keyword]
+
+        return trimmed
+
     def format_filename(self, formatter: FilenameFormatter) -> str:
         """Format filename with given formatter."""
         self._header["FNAME"] = formatter(self._header)

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/images/processors/calibration/_ccddata_calibrator.py

@@ -4,17 +4,16 @@ import astropy.units as u
 from astropy.nddata import CCDData
 
 from pyobs.images import Image
-from pyobs.utils.pipeline import Pipeline
 
 
 class _CCDDataCalibrator:
     def __init__(self, image: Image, bias: Image | None = None, dark: Image | None = None, flat: Image | None = None):
-        self._image = image
+        self._image = image.trim()
         self._bias = self._optional_to_ccddata(bias)
         self._dark = self._optional_to_ccddata(dark)
         self._flat = self._optional_to_ccddata(flat)
 
-        self._ccd_data = image.to_ccddata()
+        self._ccd_data = self._image.to_ccddata()
 
         if dark is not None:
             self._dark_exp_time = dark.header["EXPTIME"]
@@ -26,16 +25,11 @@ class _CCDDataCalibrator:
         return image.to_ccddata()
 
     def __call__(self) -> Image:
-        self._trim_image()
-
         calibrated_ccd_data = self._calibrate_image()
 
         calibrated = Image.from_ccddata(calibrated_ccd_data)
         return calibrated
 
-    def _trim_image(self) -> None:
-        self._ccd_data = Pipeline.trim_ccddata(self._ccd_data)
-
     def _calibrate_image(self) -> CCDData:
         import ccdproc
 

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/images/processors/misc/circularmask.py

@@ -17,8 +17,9 @@ class CircularMask(ImageProcessor):
 
     This processor reads the circle center from two FITS header keywords
     (e.g., CRPIX1/CRPIX2) and constructs a circular mask in pixel coordinates. Pixels
-    outside the circle are set to zero by in-place multiplication; pixels inside the
-    circle are preserved. The modified image is returned.
+    outside the circle are flagged in ``image.mask``; pixel data are left untouched. Any
+    pre-existing mask on the image is combined (logical OR) with the new one rather than
+    being overwritten.
 
     :param float radius: Radius of the circular pass region in pixels. Pixels with
                          squared distance to the center less than or equal to
@@ -33,17 +34,19 @@ class CircularMask(ImageProcessor):
     --------
     - Reads the circle center from ``image.header[center[0]]`` and
       ``image.header[center[1]]``.
-    - Builds a boolean circular mask on the 2D pixel grid and applies it to
-      ``image.data`` by element-wise multiplication, zeroing pixels outside the
-      circle and keeping those inside (boundary inclusive).
-    - Returns the same image object with modified pixel data; the FITS header and
+    - Builds a boolean mask on the 2D pixel grid that is ``True`` outside the circle
+      and ``False`` inside it (boundary inclusive), and assigns it to a copy of the
+      image's ``mask``. If the image already has a mask, the new mask is combined with
+      it via logical OR instead of replacing it.
+    - Returns a copy of the image with the updated mask; pixel data, header, and
       catalog are not changed.
 
     Input/Output
     ------------
     - Input: :class:`pyobs.images.Image` with 2D pixel data and FITS header containing
       the specified center keywords.
-    - Output: :class:`pyobs.images.Image` with pixel data masked outside the circle.
+    - Output: :class:`pyobs.images.Image` (copied) with pixels outside the circle
+      marked in ``mask``; pixel data are unchanged.
 
     Configuration (YAML)
     --------------------
@@ -70,8 +73,6 @@ class CircularMask(ImageProcessor):
       ensure consistency to avoid off-by-one shifts.
     - The implementation operates on 2D images. Multi-plane/color images are not
       supported by this processor as written.
-    - Masking is performed in place; if you need to preserve the original image data,
-      copy the image before applying this processor.
     """
 
     __module__ = "pyobs.images.processors.misc"
@@ -90,13 +91,13 @@ class CircularMask(ImageProcessor):
         self._radius = radius
 
     async def __call__(self, image: Image) -> Image:
-        """Remove everything outside the given radius from the image.
+        """Mask everything outside the given radius from the image.
 
         Args:
             image: Image to mask.
 
         Returns:
-            Masked Image.
+            Image with pixels outside the circle marked in its mask.
         """
 
         center_x, center_y = image.header[self._center[0]], image.header[self._center[1]]
@@ -105,10 +106,16 @@ class CircularMask(ImageProcessor):
         x, y = np.arange(0, nx), np.arange(0, ny)
         x_coordinates, y_coordinates = np.meshgrid(x, y)
 
-        circ_mask = (x_coordinates - center_x) ** 2 + (y_coordinates - center_y) ** 2 <= self._radius**2
+        outside_circle = (x_coordinates - center_x) ** 2 + (y_coordinates - center_y) ** 2 > self._radius**2
+        outside_circle = outside_circle.transpose()
 
-        image.data *= circ_mask.transpose()
-        return image
+        output_image = image.copy()
+        if output_image.safe_mask is not None:
+            output_image.mask = np.logical_or(output_image.mask, outside_circle)
+        else:
+            output_image.mask = outside_circle
+
+        return output_image
 
 
 __all__ = ["CircularMask"]

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/images/processors/offsets/projected.py

@@ -1,5 +1,4 @@
 import logging
-import re
 from typing import Any, cast
 
 import numpy as np
@@ -9,6 +8,7 @@ from scipy.optimize import fmin
 
 from pyobs.images import Image
 from pyobs.images.meta import PixelOffsets
+from pyobs.utils.fits import fitssec
 
 from .offsets import Offsets
 
@@ -155,16 +155,8 @@ class ProjectedOffsets(Offsets):
             Projected images.
         """
 
-        # get image data and header
-        data, hdr = image.data, image.header
-
-        # trimsec
-        if "TRIMSEC" in hdr:
-            m = re.match(r"\[([0-9]+):([0-9]+),([0-9]+):([0-9]+)\]", hdr["TRIMSEC"])
-            if m is None:
-                raise ValueError("Invalid trimsec.")
-            x0, x1, y0, y1 = [int(f) for f in m.groups()]
-            data = data[y0 - 1 : y1, x0 - 1 : x1]
+        # trim to trimsec, if set
+        data = fitssec(image)
 
         # collapse
         sum_x = np.nansum(data, 0)

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/interfaces/ICamera.py

@@ -1,10 +1,9 @@
 from abc import ABCMeta
 
 from .IData import IData
-from .IExposure import IExposure
 
 
-class ICamera(IData, IExposure, metaclass=ABCMeta):
+class ICamera(IData, metaclass=ABCMeta):
     """The module controls a camera."""
 
     __module__ = "pyobs.interfaces"

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/interfaces/IDataSequence.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Annotated, Any
 
+from ..utils.enums import Unit
 from ..utils.time import Time
 from .IAbortable import IAbortable
 
@@ -23,13 +24,18 @@ class IDataSequence(IAbortable, metaclass=ABCMeta):
     state = DataSequenceState
 
     @abstractmethod
-    async def grab_sequence(self, count: int, broadcast: bool = True, **kwargs: Any) -> None:
+    async def grab_sequence(
+        self, count: int, broadcast: bool = True, delay: Annotated[float, Unit.SECONDS] = 0, **kwargs: Any
+    ) -> None:
         """Start a sequence of `count` grabs. Returns immediately; progress is available via
         the pushed DataSequenceState.
 
         Args:
             count: Number of grabs to take.
             broadcast: Broadcast existence of each grab.
+            delay: Seconds to wait between the end of one grab and the start of the next.
+                Does not apply after the last grab. Skipped early if the sequence is aborted
+                during the wait.
 
         Raises:
             GrabImageError: If the device is already busy (exposing or already running a

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/interfaces/ISpectrograph.py

@@ -1,10 +1,9 @@
 from abc import ABCMeta
 
 from .IData import IData
-from .IExposure import IExposure
 
 
-class ISpectrograph(IData, IExposure, metaclass=ABCMeta):
+class ISpectrograph(IData, metaclass=ABCMeta):
     """The module controls a camera."""
 
     __module__ = "pyobs.interfaces"

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/mixins/camerasettings.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Any, cast
 
+from pyobs.comm.proxy import Proxy
 from pyobs.interfaces import IBinning, IData, IFilters, IWindow
 from pyobs.modules import Module
 
@@ -54,7 +55,10 @@ class CameraSettingsMixin:
             await camera.set_binning(self.__camerasettings_binning, self.__camerasettings_binning)
         if isinstance(camera, IWindow):
             log.info("Set window to full frame...")
-            cap = camera.get_capabilities(IWindow)
+            if isinstance(camera, Proxy):
+                cap = await camera.wait_for_capabilities(IWindow)
+            else:
+                cap = camera.get_capabilities(IWindow)
             if cap is not None:
                 await camera.set_window(cap.full_frame_x, cap.full_frame_y, cap.full_frame_width, cap.full_frame_height)
             else:

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/camera/basecamera.py

@@ -46,7 +46,9 @@ async def calc_expose_timeout(camera: BaseCamera, *args: Any, **kwargs: Any) ->
     return camera._exposure_time + 30
 
 
-class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageType, IDataSequence, metaclass=ABCMeta):
+class BaseCamera(
+    Module, ImageFitsHeaderMixin, ICamera, IExposure, IExposureTime, IImageType, IDataSequence, metaclass=ABCMeta
+):
     """Base class for all camera modules."""
 
     __module__ = "pyobs.modules.camera"
@@ -108,6 +110,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         # (also between individual grabs, while _camera_status is briefly IDLE again)
         self._sequence_count_left = 0
         self._sequence_task: asyncio.Task[None] | None = None
+        self._sequence_delay_abort = asyncio.Event()
 
         # register exception
         exc.register_exception(exc.GrabImageError, 3, timespan=600, callback=self._default_remote_error_callback)
@@ -370,19 +373,23 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         # return filename
         return filename
 
-    async def grab_sequence(self, count: int, broadcast: bool = True, **kwargs: Any) -> None:
+    async def grab_sequence(self, count: int, broadcast: bool = True, delay: float = 0, **kwargs: Any) -> None:
         """Start a sequence of `count` images. Returns immediately; progress is available via
         the pushed DataSequenceState.
 
         Args:
             count: Number of images to take.
             broadcast: Broadcast existence of each image.
+            delay: Seconds to wait between the end of one image and the start of the next.
+                Does not apply after the last image.
 
         Raises:
             CameraException: If camera is already busy (exposing or already running a sequence).
         """
         if count < 1:
             raise ValueError("count must be >= 1.")
+        if delay < 0:
+            raise ValueError("delay must be >= 0.")
 
         # already running a sequence, or mid-exposure outside of one?
         if self._sequence_count_left > 0 or self._camera_status != ExposureStatus.IDLE:
@@ -391,9 +398,9 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         log.info("Starting sequence of %d images...", count)
         self._sequence_count_left = count
         await self.comm.set_state(IDataSequence, DataSequenceState(count_total=count, count_left=count))
-        self._sequence_task = asyncio.create_task(self._run_sequence(count, broadcast))
+        self._sequence_task = asyncio.create_task(self._run_sequence(count, broadcast, delay))
 
-    async def _run_sequence(self, count_total: int, broadcast: bool) -> None:
+    async def _run_sequence(self, count_total: int, broadcast: bool, delay: float) -> None:
         """Runs a sequence of grab_data() calls, started by grab_sequence()."""
         try:
             while self._sequence_count_left > 0:
@@ -406,6 +413,15 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
                 await self.comm.set_state(
                     IDataSequence, DataSequenceState(count_total=count_total, count_left=self._sequence_count_left)
                 )
+
+                # wait between images, unless this was the last one or the sequence was
+                # aborted in the meantime -- either abort_sequence() or abort() cuts this short
+                if self._sequence_count_left > 0 and delay > 0:
+                    self._sequence_delay_abort.clear()
+                    try:
+                        await asyncio.wait_for(self._sequence_delay_abort.wait(), timeout=delay)
+                    except TimeoutError:
+                        pass
         finally:
             log.info("Finished sequence.")
             self._sequence_count_left = 0
@@ -418,6 +434,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         """
         log.info("Aborting sequence after current image...")
         self._sequence_count_left = 0
+        self._sequence_delay_abort.set()
 
     async def _abort_exposure(self) -> None:
         """Abort the running exposure. Should be implemented by derived class.
@@ -438,6 +455,7 @@ class BaseCamera(Module, ImageFitsHeaderMixin, ICamera, IExposureTime, IImageTyp
         log.info("Aborting current image and sequence...")
         self.expose_abort.set()
         self._sequence_count_left = 0
+        self._sequence_delay_abort.set()
 
         # do camera-specific abort
         await self._abort_exposure()

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/camera/basespectrograph.py

@@ -23,7 +23,7 @@ class ExposureInfo(NamedTuple):
     start: datetime
 
 
-class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, metaclass=ABCMeta):
+class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure, metaclass=ABCMeta):
     """Base class for all spectrograph modules."""
 
     __module__ = "pyobs.modules.camera"

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/camera/pipelinecamera.py

@@ -3,11 +3,11 @@ from typing import Any
 
 from pyobs.events import NewImageEvent
 from pyobs.images import Image
-from pyobs.interfaces import ExposureState, ICamera, IExposure
+from pyobs.interfaces import ICamera
 from pyobs.mixins import ImageFitsHeaderMixin
 from pyobs.mixins.pipeline import PipelineMixin
 from pyobs.modules import Module
-from pyobs.utils.enums import ExposureStatus, ImageType
+from pyobs.utils.enums import ImageType
 from pyobs.utils.exceptions import GrabImageError
 
 log = logging.getLogger(__name__)
@@ -24,15 +24,6 @@ class PipelineCamera(Module, ICamera, ImageFitsHeaderMixin, PipelineMixin):
         PipelineMixin.__init__(self, **kwargs)
         ImageFitsHeaderMixin.__init__(self, **kwargs)
 
-    async def open(self) -> None:
-        """Open module."""
-        await Module.open(self)
-
-        # publish initial state
-        await self.comm.set_state(
-            IExposure, ExposureState(status=ExposureStatus.IDLE, progress=0.0, exposure_time_left=0.0)
-        )
-
     async def grab_data(self, broadcast: bool = True, **kwargs: Any) -> str:
         """Grabs an image and returns reference.
 

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/pointing/guidingstatistics/pixeloffset.py

@@ -36,8 +36,8 @@ class GuidingStatisticsPixelOffset(GuidingStatistics[Image, tuple[float, float]]
         rms = self._calc_rms(data)
 
         if rms is not None:
-            header["GUIDING RMS1"] = FitsHeaderEntry(float(rms[0]), "RMS for guiding on axis 1")
-            header["GUIDING RMS2"] = FitsHeaderEntry(float(rms[1]), "RMS for guiding on axis 2")
+            header["HIERARCH GUIDING RMS1"] = FitsHeaderEntry(float(rms[0]), "RMS for guiding on axis 1")
+            header["HIERARCH GUIDING RMS2"] = FitsHeaderEntry(float(rms[1]), "RMS for guiding on axis 2")
 
         return header
 

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/pointing/guidingstatistics/skyoffsets.py

@@ -37,7 +37,7 @@ class GuidingStatisticsSkyOffset(GuidingStatistics[Image, float]):
         rms = self._calc_rms(data)
 
         if rms is not None:
-            header["GUIDING RMS"] = FitsHeaderEntry(float(rms), "RMS for guiding on sky")
+            header["HIERARCH GUIDING RMS"] = FitsHeaderEntry(float(rms), "RMS for guiding on sky")
 
         return header
 

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/pointing/guidingstatistics/uptime.py

@@ -44,7 +44,7 @@ class GuidingStatisticsUptime(GuidingStatistics[bool, tuple[bool | None, datetim
         data.append((None, now))
 
         uptime_percentage = self._calc_uptime_percentage(data)
-        return {"GUIDING UPTIME": FitsHeaderEntry(uptime_percentage, "Time the guiding loop was closed [%]")}
+        return {"HIERARCH GUIDING UPTIME": FitsHeaderEntry(uptime_percentage, "Time the guiding loop was closed [%]")}
 
     def _get_session_data(self, input_data: bool) -> tuple[bool | None, datetime] | None:
         now = datetime.now()

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/robotic/scheduler.py

@@ -281,14 +281,21 @@ class Scheduler(Module, IStartStop, IRunnable):
             # sleep a little
             await asyncio.sleep(1)
 
-    @staticmethod
-    def _log_scheduled_task(scheduled_tasks: ObservationList) -> None:
+    def _log_scheduled_task(self, scheduled_tasks: ObservationList) -> None:
+        try:
+            observer = self._scheduler.observer
+        except AttributeError:
+            observer = None
         for scheduled_task in scheduled_tasks:
             msg = f"  - {scheduled_task.start.strftime('%H:%M:%S')} to {scheduled_task.end.strftime('%H:%M:%S')}: "
             msg += f"{scheduled_task.task.name} ({scheduled_task.task.id}"
             if scheduled_task.priority is not None:
                 msg += f", priority: {scheduled_task.priority}"
             msg += ")"
+            if scheduled_task.target is not None and observer is not None:
+                start = Time(scheduled_task.start)
+                altaz = observer.altaz(start, scheduled_task.target.coordinates(start))
+                msg += f" [{scheduled_task.target.name}: alt={altaz.alt.degree:.1f}°, airmass={float(altaz.secz):.2f}]"
             log.info(msg)
 
     async def run(self, **kwargs: Any) -> None:

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/modules/telescope/basetelescope.py

@@ -308,7 +308,14 @@ class BaseTelescope(
 
         # check altitude
         if alt_az.alt.degree < self._min_altitude:
-            raise ValueError("Destination altitude below limit.")
+            raise ValueError(
+                f"Destination altitude below limit: alt={alt_az.alt.degree:.2f}° "
+                f"az={alt_az.az.degree:.2f}° (min={self._min_altitude:.2f}°) for "
+                f"ra={ra:.5f}° dec={dec:.5f}° at {Time.now().isot} from "
+                f"lon={self.observer.location.lon.degree:.4f}° "
+                f"lat={self.observer.location.lat.degree:.4f}° "
+                f"height={self.observer.location.height.value:.1f}m."
+            )
 
         # acquire lock
         async with LockWithAbort(self._lock_moving, self._abort_move):
@@ -382,7 +389,10 @@ class BaseTelescope(
 
         # check altitude
         if alt < self._min_altitude:
-            raise ValueError("Destination altitude below limit.")
+            raise ValueError(
+                f"Destination altitude below limit: alt={alt:.2f}° az={az:.2f}° "
+                f"(min={self._min_altitude:.2f}°) at {Time.now().isot}."
+            )
 
         # acquire lock
         async with LockWithAbort(self._lock_moving, self._abort_move):

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/robotic/storage/lco/scripts/script.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
+from pydantic import PrivateAttr
+
 from pyobs.interfaces import FitsHeaderEntry
 from pyobs.robotic.scripts import Script
 from pyobs.robotic.storage.lco._portal import LcoRequest
@@ -24,6 +26,8 @@ class LcoScript(Script):
     request: LcoRequest
     scripts: dict[str, dict[str, Any]] = {}
 
+    _running_script: Script | None = PrivateAttr(default=None)
+
     def _create_script(self) -> Script:
         """Build the script selected via the configuration's extra_params["script_name"].
 
@@ -55,6 +59,7 @@ class LcoScript(Script):
             InterruptedError: If interrupted
         """
         script = self._create_script()
+        self._running_script = script
         try:
             await script.run(data)
         finally:
@@ -69,7 +74,8 @@ class LcoScript(Script):
         Returns:
             Dictionary containing FITS headers.
         """
-        return self._create_script().get_fits_headers(namespaces)
+        script = self._running_script if self._running_script is not None else self._create_script()
+        return script.get_fits_headers(namespaces)
 
     def estimate_duration(self, data: TaskData | None = None, time: Time | None = None) -> float:
         """Estimate duration based on the duration calculated by the LCO portal."""

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/robotic/storage/lco/task.py

@@ -184,6 +184,7 @@ class LcoTask(Task):
         # at least we tried...
         config_status = ConfigStatus()
         script = self.pyobs_model_validate(Script, self.script, by_alias=True)
+        self._running_script = script
 
         try:
             # run it
@@ -232,9 +233,11 @@ class LcoTask(Task):
             Dictionary containing FITS headers.
         """
 
-        # get header from the script
-
-        script = self.pyobs_model_validate(Script, self.script, by_alias=True)
+        # use the actively running script instance if there is one, so we pick up its
+        # accumulated state (e.g. current target name); otherwise fall back to a fresh one
+        script = self._running_script
+        if script is None:
+            script = self.pyobs_model_validate(Script, self.script, by_alias=True)
         hdr = script.get_fits_headers(namespaces)
 
         # return it

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/robotic/task.py

@@ -41,6 +41,7 @@ class Task(BaseModel):
 
     _resolved_target: Target | None = PrivateAttr(default=None)
     _cant_run_reason: str | None = None
+    _running_script: Script | None = PrivateAttr(default=None)
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -85,7 +86,9 @@ class Task(BaseModel):
     async def run(self, data: TaskData | None) -> None:
         """Run a task"""
         if self.script is not None:
-            await self.create_script().run(data)
+            script = self.create_script()
+            self._running_script = script
+            await script.run(data)
 
     def is_finished(self) -> bool:
         """Whether task is finished."""
@@ -100,7 +103,9 @@ class Task(BaseModel):
         Returns:
             Dictionary containing FITS headers.
         """
-        return {}
+        if self._running_script is None:
+            return {}
+        return self._running_script.get_fits_headers(namespaces)
 
     def estimate_duration(self, time: Time | None = None) -> float:
         if self.script:

{pyobs_core-2.0.0.dev24 → pyobs_core-2.0.0.dev27}/pyobs/utils/curvefit.py

@@ -29,8 +29,20 @@ def fit_hyperbola(x_arr: list[float], y_arr: list[float], y_err: list[float]) ->
     p0 = [a, b, c]
 
     # fit
+    #
+    # absolute_sigma=True is required here: without it, curve_fit treats y_err as only
+    # relative weights and rescales the returned covariance matrix so that the fit's
+    # reduced chi-square equals 1. That makes the reported variance reflect how well the
+    # hyperbola shape matches this particular focus run rather than the actual per-point
+    # measurement uncertainty passed in via y_err, which silently miscalibrates every
+    # downstream error estimate.
     coeffs, cov = curve_fit(
-        lambda xx, aa, bb, cc: bb * np.sqrt((xx - cc) ** 2 / aa**2 + 1.0), x_arr, y_arr, sigma=y_err, p0=p0
+        lambda xx, aa, bb, cc: bb * np.sqrt((xx - cc) ** 2 / aa**2 + 1.0),
+        x_arr,
+        y_arr,
+        sigma=y_err,
+        p0=p0,
+        absolute_sigma=True,
     )
 
     # return result