pyobs-core 2.0.0.dev23__tar.gz → 2.0.0.dev26__tar.gz

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/PKG-INFO

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

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/pyobs/comm/comm.py

@@ -133,16 +133,14 @@ class Comm:
             except IndexError:
                 return None
 
-            # collect capabilities (fixed at proxy construction time)
-            capabilities: dict[type[Interface], Any] = {}
+            # create new proxy
+            proxy = Proxy(self, client, interfaces)
+
+            # fetch capabilities in the background, so a peer that isn't fully up yet doesn't block
+            # proxy construction -- Proxy.wait_for_capabilities() can be used to wait for the result
             for interface in interfaces:
                 if interface.capabilities is not None:
-                    cap = await self._get_capabilities(client, interface)
-                    if cap is not None:
-                        capabilities[interface] = cap
-
-            # create new proxy
-            proxy = Proxy(self, client, interfaces, capabilities)
+                    asyncio.create_task(self._fetch_and_update_capabilities(client, interface, proxy))
 
             # subscribe to state
             for interface in interfaces:
@@ -151,9 +149,14 @@ class Comm:
 
             self._proxies[client] = proxy
 
-        # return proxy
         return self._proxies[client]
 
+    async def _fetch_and_update_capabilities(self, client: str, interface: type[Interface], proxy: Proxy) -> None:
+        """Fetch capabilities for a single interface and push them into the given proxy once available."""
+        cap = await self._get_capabilities(client, interface)
+        if cap is not None:
+            proxy.update_capabilities(interface, cap)
+
     async def _resolve_proxy(
         self, name_or_object: str | object, obj_type: type[ProxyType] | None = None
     ) -> Any | ProxyType:

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/pyobs/comm/proxy.py

@@ -62,6 +62,7 @@ class Proxy:
         # store state and capabilities
         self._state: dict[type[Interface], Any] = {}
         self._capabilities: dict[type[Interface], Any] = capabilities if capabilities is not None else {}
+        self._capabilities_events: dict[type[Interface], asyncio.Event] = {}
 
     @property
     def name(self) -> str:
@@ -175,8 +176,18 @@ class Proxy:
         """Latest known state for the given interface, or None if nothing has arrived yet."""
         return self._state.get(interface)
 
+    def update_capabilities(self, interface: type[Interface], capabilities: Any) -> None:
+        """Called by Comm once capabilities for an interface arrive.
+
+        Not intended to be called directly by module code.
+        """
+        self._capabilities[interface] = capabilities
+        event = self._capabilities_events.get(interface)
+        if event is not None:
+            event.set()
+
     def get_capabilities(self, interface: type[Interface]) -> Any | None:
-        """Capabilities for the given interface, populated once at Proxy construction."""
+        """Capabilities for the given interface, or None if not (yet) fetched."""
         return self._capabilities.get(interface)
 
     async def wait_for_state(
@@ -203,6 +214,23 @@ class Proxy:
 
         return self._state.get(interface)
 
+    async def wait_for_capabilities(
+        self,
+        interface: type[Interface],
+        timeout: float = 10.0,
+    ) -> Any | None:
+        """Return capabilities immediately if available, otherwise wait for the background fetch to complete."""
+        if self._capabilities.get(interface) is not None:
+            return self._capabilities[interface]
+
+        event = self._capabilities_events.setdefault(interface, asyncio.Event())
+        try:
+            await asyncio.wait_for(event.wait(), timeout=timeout)
+        except TimeoutError:
+            pass
+
+        return self._capabilities.get(interface)
+
 
 class _ProxyContext(Generic[ProxyType]):
     """Returned by Comm.proxy() / Object.proxy() / Comm.safe_proxy(). Must be used as:

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/pyobs/comm/xmpp/xmppclient.py

@@ -48,7 +48,7 @@ class XmppClient(slixmpp.ClientXMPP):
         self.register_plugin("xep_0199")  # XMPP Ping
 
         # enable keep alive pings
-        self["xep_0199"].enable_keepalive()
+        self.plugin["xep_0199"].enable_keepalive()
 
         # handle session_start and message events
         self.add_event_handler("session_start", self.session_start)

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/pyobs/comm/xmpp/xmppcomm.py

@@ -909,20 +909,34 @@ class XmppComm(Comm):
         return self._capabilities.get(interface)
 
     async def _get_capabilities(self, module: str, interface: type[Interface]) -> Any | None:
-        """Fetch and deserialize capabilities for a remote module's interface."""
+        """Fetch and deserialize capabilities for a remote module's interface.
+
+        Retries a few times, since this may run right as the peer is still starting up and hasn't
+        published its capabilities yet.
+        """
         if interface.capabilities is None:
             return None
-        # Use full JID (with resource) if we know it — bare JID may not route correctly
-        full_jid = next(
-            (jid for jid in self._online_clients if jid.startswith(f"{module}@")),
-            f"{module}@{self._domain}",
-        )
-        jid = full_jid
         ns = f"urn:pyobs:capabilities:{interface.__name__}:{interface.version}"
-        try:
-            result = await asyncio.wait_for(self.client.plugin["xep_0030"].get_info(jid=JID(jid)), timeout=10.0)
-        except (TimeoutError, Exception) as e:
-            log.warning("Failed to get capabilities for %s from %s: %s", interface.__name__, module, e)
+
+        result = None
+        last_error: BaseException | None = None
+        for attempt in range(3):
+            # Use full JID (with resource) if we know it — bare JID may not route correctly
+            full_jid = next(
+                (jid for jid in self._online_clients if jid.startswith(f"{module}@")),
+                f"{module}@{self._domain}",
+            )
+            try:
+                result = await asyncio.wait_for(
+                    self.client.plugin["xep_0030"].get_info(jid=JID(full_jid)), timeout=10.0
+                )
+                break
+            except (TimeoutError, Exception) as e:
+                last_error = e
+                if attempt < 2:
+                    await asyncio.sleep(2)
+        else:
+            log.warning("Failed to get capabilities for %s from %s: %s", interface.__name__, module, last_error)
             return None
         log.debug("get_capabilities disco result XML: %s", ET.tostring(result.xml).decode()[:500])
         # result.xml is the <iq> — the <query> is its child, capabilities are grandchildren

{pyobs_core-2.0.0.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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.dev23 → pyobs_core-2.0.0.dev26}/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."""