pyobs-core 2.9.2__tar.gz → 2.10.0__tar.gz

{pyobs_core-2.9.2 → pyobs_core-2.10.0}/PKG-INFO

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

{pyobs_core-2.9.2 → pyobs_core-2.10.0}/pyobs/mixins/__init__.py

@@ -5,6 +5,7 @@ Mixins are classes that can be inherited from to automatically add some function
 __title__ = "Mixins"
 
 from .camerasettings import CameraSettingsMixin
+from .datasequence import DataSequenceMixin
 from .fitsheader import (
     FilterHeaderMixin,
     FitsHeaderMixin,
@@ -26,6 +27,7 @@ __all__ = [
     "WaitForMotionMixin",
     "WeatherAwareMixin",
     "CameraSettingsMixin",
+    "DataSequenceMixin",
     "ImageFitsHeaderMixin",
     "SpectrumFitsHeaderMixin",
     "FilterHeaderMixin",

pyobs_core-2.10.0/pyobs/mixins/datasequence.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from abc import ABCMeta, abstractmethod
+from typing import Any
+
+from pyobs.interfaces import DataSequenceState, IDataSequence
+from pyobs.modules import Module
+from pyobs.utils import exceptions as exc
+
+log = logging.getLogger(__name__)
+
+
+class DataSequenceMixin(IDataSequence, metaclass=ABCMeta):
+    """Implements IDataSequence.grab_sequence()/abort_sequence() on top of a host's grab_data().
+
+    Shared by BaseCamera and BaseSpectrograph, whose grab_data() implementations differ only in
+    what they grab. The host class must:
+      - be a Module (comm is used to publish DataSequenceState)
+      - implement grab_data(broadcast, **kwargs) -> str
+      - implement _sequence_busy(), reporting whether it's busy outside of a running sequence
+        (e.g. mid-exposure)
+      - call _abort_data_sequence() from its own abort() implementation, so a hard abort also cuts
+        short a sequence waiting out its inter-grab delay (there's no exception to catch in that
+        case, unlike an abort during grab_data() itself, which grab_data() surfaces as a
+        PyobsError that _run_sequence() below already ends the sequence on)
+    """
+
+    __module__ = "pyobs.mixins"
+
+    def __init__(self, **kwargs: Any):
+        # count_left > 0 means a sequence is currently running (also between individual grabs,
+        # while the host's own status is briefly IDLE again)
+        self._sequence_count_left = 0
+        self._sequence_task: asyncio.Task[None] | None = None
+        self._sequence_delay_abort = asyncio.Event()
+        super().__init__(**kwargs)
+
+    async def _datasequence_open(self) -> None:
+        """Call from the host's open() to publish the initial idle sequence state."""
+        if not isinstance(self, Module):
+            raise ValueError("This is not a module.")
+        await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
+
+    @abstractmethod
+    async def grab_data(self, broadcast: bool = True, **kwargs: Any) -> str: ...
+
+    @abstractmethod
+    def _sequence_busy(self) -> bool:
+        """Whether the device is currently busy outside of a running sequence."""
+        ...
+
+    async def grab_sequence(self, count: int, broadcast: bool = True, delay: float = 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.
+
+        Raises:
+            InvalidArgumentError: If count or delay is out of range.
+            DeviceBusyError: If the device is already busy (exposing or already running a
+                sequence).
+        """
+        if not isinstance(self, Module):
+            raise ValueError("This is not a module.")
+
+        if count < 1:
+            raise exc.InvalidArgumentError("count must be >= 1.")
+        if delay < 0:
+            raise exc.InvalidArgumentError("delay must be >= 0.")
+
+        if self._sequence_count_left > 0 or self._sequence_busy():
+            raise exc.DeviceBusyError("Cannot start new sequence because device is not idle.")
+
+        log.info("Starting sequence of %d grabs...", 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, delay))
+
+    async def _run_sequence(self, count_total: int, broadcast: bool, delay: float) -> None:
+        """Runs a sequence of grab_data() calls, started by grab_sequence()."""
+        if not isinstance(self, Module):
+            raise ValueError("This is not a module.")
+
+        try:
+            while self._sequence_count_left > 0:
+                try:
+                    await self.grab_data(broadcast=broadcast)
+                except exc.PyobsError:
+                    log.exception("Grab failed during sequence, aborting sequence.")
+                    break
+                self._sequence_count_left -= 1
+                await self.comm.set_state(
+                    IDataSequence, DataSequenceState(count_total=count_total, count_left=self._sequence_count_left)
+                )
+
+                # wait between grabs, 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
+            self._sequence_task = None
+            await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
+
+    async def abort_sequence(self, **kwargs: Any) -> None:
+        """Stop the sequence after the current grab. The grab currently in progress, if any,
+        finishes normally; no further grabs in the sequence are started.
+        """
+        log.info("Aborting sequence after current grab...")
+        self._abort_data_sequence()
+
+    def _abort_data_sequence(self) -> None:
+        """Clear sequence bookkeeping and cut short an in-progress inter-grab delay wait.
+
+        Call this from the host's own abort() alongside its hardware-specific abort logic.
+        """
+        self._sequence_count_left = 0
+        self._sequence_delay_abort.set()
+
+
+__all__ = ["DataSequenceMixin"]

{pyobs_core-2.9.2 → pyobs_core-2.10.0}/pyobs/modules/camera/basecamera.py

@@ -12,16 +12,15 @@ from astropy.io import fits
 from pyobs.events import BadWeatherEvent, Event, ExposureStatusChangedEvent, NewImageEvent
 from pyobs.images import Image
 from pyobs.interfaces import (
-    DataSequenceState,
     ExposureState,
     ExposureTimeState,
     ICamera,
-    IDataSequence,
     IExposure,
     IExposureTime,
     IImageType,
     ImageTypeState,
 )
+from pyobs.mixins.datasequence import DataSequenceMixin
 from pyobs.mixins.fitsheader import ImageFitsHeaderMixin
 from pyobs.modules import Module, timeout
 from pyobs.utils import exceptions as exc
@@ -43,7 +42,7 @@ async def calc_expose_timeout(camera: BaseCamera, *args: Any, **kwargs: Any) ->
 
 
 class BaseCamera(
-    Module, ImageFitsHeaderMixin, ICamera, IExposure, IExposureTime, IImageType, IDataSequence, metaclass=ABCMeta
+    Module, ImageFitsHeaderMixin, ICamera, IExposure, IExposureTime, IImageType, DataSequenceMixin, metaclass=ABCMeta
 ):
     """Base class for all camera modules."""
 
@@ -104,12 +103,6 @@ class BaseCamera(
         # multi-threading
         self.expose_abort = asyncio.Event()
 
-        # grab_sequence() state -- count_left > 0 means a sequence is currently running
-        # (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
         self._register_exception(exc.GrabImageError, 3, timespan=600, callback=self._default_remote_error_callback)
 
@@ -138,7 +131,7 @@ class BaseCamera(
                 exposure_time_left=0.0,
             ),
         )
-        await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
+        await self._datasequence_open()
 
     async def set_exposure_time(self, exposure_time: float, **kwargs: Any) -> None:
         """Set the exposure time in seconds.
@@ -402,69 +395,9 @@ class BaseCamera(
         # return filename
         return filename
 
-    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:
-            InvalidArgumentError: If count or delay is out of range.
-            DeviceBusyError: If camera is already busy (exposing or already running a sequence).
-        """
-        if count < 1:
-            raise exc.InvalidArgumentError("count must be >= 1.")
-        if delay < 0:
-            raise exc.InvalidArgumentError("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:
-            raise exc.DeviceBusyError("Cannot start new sequence because camera is not idle.")
-
-        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, delay))
-
-    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:
-                try:
-                    await self.grab_data(broadcast=broadcast)
-                except exc.PyobsError:
-                    log.exception("Grab failed during sequence, aborting sequence.")
-                    break
-                self._sequence_count_left -= 1
-                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
-            self._sequence_task = None
-            await self.comm.set_state(IDataSequence, DataSequenceState(count_total=0, count_left=0))
-
-    async def abort_sequence(self, **kwargs: Any) -> None:
-        """Stop the sequence after the current image. The image currently exposing, if any,
-        finishes normally; no further images in the sequence are started.
-        """
-        log.info("Aborting sequence after current image...")
-        self._sequence_count_left = 0
-        self._sequence_delay_abort.set()
+    def _sequence_busy(self) -> bool:
+        """Whether the camera is busy exposing outside of a running sequence."""
+        return self._camera_status != ExposureStatus.IDLE
 
     async def _abort_exposure(self) -> None:
         """Abort the running exposure. Should be implemented by derived class.
@@ -484,8 +417,7 @@ class BaseCamera(
         # set abort event
         log.info("Aborting current image and sequence...")
         self.expose_abort.set()
-        self._sequence_count_left = 0
-        self._sequence_delay_abort.set()
+        self._abort_data_sequence()
 
         # do camera-specific abort
         await self._abort_exposure()

{pyobs_core-2.9.2 → pyobs_core-2.10.0}/pyobs/modules/camera/basespectrograph.py

@@ -10,6 +10,7 @@ from astropy.io import fits
 
 from pyobs.events import ExposureStatusChangedEvent, NewSpectrumEvent
 from pyobs.interfaces import ExposureState, IExposure, ISpectrograph
+from pyobs.mixins.datasequence import DataSequenceMixin
 from pyobs.mixins.fitsheader import SpectrumFitsHeaderMixin
 from pyobs.modules import Module, timeout
 from pyobs.utils import exceptions as exc
@@ -24,7 +25,7 @@ class ExposureInfo(NamedTuple):
     start: datetime
 
 
-class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure, metaclass=ABCMeta):
+class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure, DataSequenceMixin, metaclass=ABCMeta):
     """Base class for all spectrograph modules."""
 
     __module__ = "pyobs.modules.camera"
@@ -66,6 +67,7 @@ class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure
         await self.comm.set_state(
             IExposure, ExposureState(status=self._spectrograph_status, progress=0.0, exposure_time_left=0.0)
         )
+        await self._datasequence_open()
 
     @abstractmethod
     async def _expose(self, abort_event: asyncio.Event) -> fits.HDUList:
@@ -206,13 +208,18 @@ class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure
         self._spectrograph_status = status
         await self.comm.set_state(IExposure, ExposureState(status=status, progress=0.0, exposure_time_left=0.0))
 
+    def _sequence_busy(self) -> bool:
+        """Whether the spectrograph is busy exposing outside of a running sequence."""
+        return self._spectrograph_status != ExposureStatus.IDLE
+
     async def abort(self, **kwargs: Any) -> None:
-        """Aborts the current exposure.
+        """Aborts the current exposure and sequence. Derived class must implement the actual
+        hardware abort for this!
 
         Raises:
             ValueError: If exposure could not be aborted.
         """
-        pass
+        self._abort_data_sequence()
 
 
 __all__ = ["BaseSpectrograph"]

{pyobs_core-2.9.2 → pyobs_core-2.10.0}/pyproject.toml

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