pyobs-core 2.0.0.dev80__tar.gz → 2.0.0.dev82__tar.gz

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/PKG-INFO

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

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/camerasettings.py

@@ -35,6 +35,8 @@ class CameraSettingsMixin:
         self.__camerasettings_filter = filter_name
         self.__camerasettings_binning = binning
 
+        super().__init__(**kwargs)
+
     async def _do_camera_settings(self, camera: Module | IData | IFilters | IBinning | IWindow) -> None:
         """Do camera settings for given camera."""
 

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/fitsheader.py

@@ -46,8 +46,6 @@ class FitsHeaderMixin:
                 them. A peer that never answers (e.g. a laptop put to sleep without closing its
                 client) would otherwise stall the frame for the full XMPP IQ timeout.
         """
-        module = cast(Module, self)
-
         # store
         self._fitsheadermixin_fits_namespaces = fits_namespaces
         self._fitsheadermixin_filename_pattern = filenames
@@ -58,10 +56,19 @@ class FitsHeaderMixin:
         self._fitsheadermixin_night_obs = night_obs
 
         # night exposure number
-        self._fitsheadermixin_cache = f"/pyobs/modules/{module.name}/cache.yaml"
         self._fitsheadermixin_enable_frame_number = frame_number
         self._fitsheadermixin_frame_number = 0
 
+        super().__init__(**kwargs)
+
+    @property
+    def _fitsheadermixin_cache(self) -> str:
+        # computed lazily (not cached at __init__ time) since it depends on module.name, which in
+        # turn depends on comm having been set up by Object.__init__ -- in a cooperative super()
+        # chain, this mixin's __init__ can run before Module has finished its own setup
+        module = cast(Module, self)
+        return f"/pyobs/modules/{module.name}/cache.yaml"
+
     async def request_fits_headers(self, before: bool = True) -> dict[str, Task[Any]]:
         """Request FITS headers from other modules.
 
@@ -309,7 +316,7 @@ class ImageFitsHeaderMixin(FitsHeaderMixin):
             rotation: Rotation east of north.
             filename: Filename pattern for FITS images.
         """
-        FitsHeaderMixin.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
         # store
         self._fitsheadermixin_centre = centre

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/fitsnamespace.py

@@ -15,6 +15,7 @@ class FitsNamespaceMixin:
 
     def __init__(self, fits_namespaces: dict[str, list[str]] | None = None, **kwargs: Any):
         self.__namespaces = {} if fits_namespaces is None else fits_namespaces
+        super().__init__(**kwargs)
 
     def _filter_fits_namespace(
         self, hdr: dict[str, FitsHeaderEntry], sender: str, namespaces: list[str] | None = None, **kwargs: Any

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/follow.py

@@ -125,6 +125,8 @@ class FollowMixin:
         if not isinstance(self, self.__follow_mode):
             raise ValueError(f"This module is not of given mode {mode}.")
 
+        super().__init__(*args, **kwargs)
+
     @property
     def is_following(self) -> bool:
         """Returns True, if we're following another device."""

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/motionstatus.py

@@ -26,6 +26,8 @@ class MotionStatusMixin:
         self.__motion_status = MotionStatus.UNKNOWN
         self.__motion_status_single = {i: MotionStatus.UNKNOWN for i in self.__motion_status_interfaces}
 
+        super().__init__(**kwargs)
+
     async def open(self) -> None:
         # subscribe to events
         if isinstance(self, Module) and self._comm:

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/pipeline.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import inspect
 import logging
 from typing import TYPE_CHECKING, Any
 
 from pyobs.images import Image, ImageProcessor
-from pyobs.object import Object
+from pyobs.object import Object, get_class_from_string
 from pyobs.utils.exceptions import ImageError
 
 if TYPE_CHECKING:
@@ -31,9 +32,10 @@ class PipelineMixin:
             archive: Default archive config/object for steps that accept one (e.g.
                 Calibration) and don't already specify their own -- lets a pipeline's
                 steps share the archive it was itself given, instead of repeating the
-                same archive config in every step that needs one. Steps that don't
-                declare an archive parameter just absorb and drop it via their own
-                **kwargs, the same as any other unrecognized Object kwarg.
+                same archive config in every step that needs one. Only injected into a
+                step's config if that step's class actually declares an `archive`
+                parameter (checked via signature inspection); steps that don't declare
+                one never receive it, rather than receiving-then-silently-dropping it.
         """
 
         # store
@@ -46,11 +48,38 @@ class PipelineMixin:
         else:
             raise ValueError("This class is no Object.")
 
+        super().__init__(**kwargs)
+
+    @staticmethod
+    def _accepts_archive(class_name: str) -> bool:
+        """Whether the given class declares an `archive` parameter anywhere in its `__init__` MRO."""
+        try:
+            klass = get_class_from_string(class_name)
+        except Exception:
+            return False
+        for cls in klass.__mro__:
+            init = cls.__dict__.get("__init__")
+            if init is None:
+                continue
+            try:
+                sig = inspect.signature(init)
+            except (TypeError, ValueError):
+                continue
+            if "archive" in sig.parameters:
+                return True
+        return False
+
     @staticmethod
     def _with_default_archive(
         step: dict[str, Any] | ImageProcessor, archive: dict[str, Any] | Archive | None
     ) -> dict[str, Any] | ImageProcessor:
-        if archive is not None and isinstance(step, dict) and "archive" not in step:
+        if (
+            archive is not None
+            and isinstance(step, dict)
+            and "archive" not in step
+            and "class" in step
+            and PipelineMixin._accepts_archive(step["class"])
+        ):
             return {**step, "archive": archive}
         return step
 

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/waitformotion.py

@@ -42,6 +42,8 @@ class WaitForMotionMixin:
         )
         self.__wait_for_timeout = wait_for_timeout
 
+        super().__init__(**kwargs)
+
     async def _wait_for_motion(self, abort: Event) -> None:
         """Wait until all devices are in one of the given motion states.
 

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/mixins/weatheraware.py

@@ -33,6 +33,8 @@ class WeatherAwareMixin:
         else:
             raise ValueError("This is not a module.")
 
+        super().__init__(**kwargs)
+
     async def open(self) -> None:
         """Open mixin."""
         # subscribe to events

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/camera/basecamera.py

@@ -76,15 +76,14 @@ class BaseCamera(
             fits_namespaces: List of namespaces for FITS headers that this camera should request
             fits_header_timeout: Maximum seconds to wait for a peer's FITS headers before skipping them.
         """
-        Module.__init__(self, **kwargs)
-        ImageFitsHeaderMixin.__init__(
-            self,
+        super().__init__(
             fits_namespaces=fits_namespaces,
             fits_headers=fits_headers,
             centre=centre,
             rotation=rotation,
             filenames=filenames,
             fits_header_timeout=fits_header_timeout,
+            **kwargs,
         )
 
         # check

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/camera/basespectrograph.py

@@ -44,10 +44,7 @@ class BaseSpectrograph(Module, SpectrumFitsHeaderMixin, ISpectrograph, IExposure
             filenames: Template for file naming.
             fits_namespaces: List of namespaces for FITS headers that this camera should request
         """
-        Module.__init__(self, **kwargs)
-        SpectrumFitsHeaderMixin.__init__(
-            self, fits_namespaces=fits_namespaces, fits_headers=fits_headers, filenames=filenames, **kwargs
-        )
+        super().__init__(fits_namespaces=fits_namespaces, fits_headers=fits_headers, filenames=filenames, **kwargs)
 
         # init camera
         self._exposure: ExposureInfo | None = None

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/camera/basevideo.py

@@ -113,15 +113,14 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
             sleep_time: Time in s with inactivity after which the camera should go to sleep.
             fits_header_timeout: Maximum seconds to wait for a peer's FITS headers before skipping them.
         """
-        Module.__init__(self, **kwargs)
-        ImageFitsHeaderMixin.__init__(
-            self,
+        super().__init__(
             fits_namespaces=fits_namespaces,
             fits_headers=fits_headers,
             centre=centre,
             rotation=rotation,
             filenames=filenames,
             fits_header_timeout=fits_header_timeout,
+            **kwargs,
         )
 
         # store

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/camera/pipelinecamera.py

@@ -20,9 +20,7 @@ class PipelineCamera(Module, ICamera, ImageFitsHeaderMixin, PipelineMixin):
 
     def __init__(self, **kwargs: Any):
         """Creates a new pipeline cammera."""
-        Module.__init__(self, **kwargs)
-        PipelineMixin.__init__(self, **kwargs)
-        ImageFitsHeaderMixin.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
     async def grab_data(self, broadcast: bool = True, **kwargs: Any) -> str:
         """Grabs an image and returns reference.

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/focus/focusseries.py

@@ -58,7 +58,7 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
             broadcast: Whether to broadcast focus series images.
             final_image: Whether to take final image with optimal focus, which is always broadcasted.
         """
-        Module.__init__(self, **kwargs)
+        super().__init__(filters=filters, filter_name=filter_name, binning=binning, **kwargs)
 
         # store focuser and camera
         self._focuser = focuser
@@ -74,9 +74,6 @@ class AutoFocusSeries(Module, CameraSettingsMixin, IAutoFocus):
         # create focus series
         self._series: FocusSeries = get_object(series, FocusSeries)
 
-        # init camera settings mixin
-        CameraSettingsMixin.__init__(self, filters=filters, filter_name=filter_name, binning=binning, **kwargs)
-
         # register exceptions
         if isinstance(camera, str):
             self._register_exception(

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/image/pipeline.py

@@ -29,8 +29,7 @@ class Pipeline(Module, PipelineMixin):
             sources: List of sources to process images from.
             interval: Interval in seconds for automatic run of pipeline.
         """
-        Module.__init__(self, **kwargs)
-        PipelineMixin.__init__(self, pipeline)
+        super().__init__(steps=pipeline, **kwargs)
 
         # only allow one option!
         if (sources is not None and interval is not None) or (sources is None and interval is None):

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/pointing/_base.py

@@ -34,11 +34,8 @@ class BasePointing(Module, PipelineMixin, metaclass=ABCMeta):
             telescope: Telescope to use.
             pipeline: Pipeline steps to run on new image. MUST include a step calculating offsets!
             apply: Object that handles applying offsets to telescope.
-            log_file: Name of file to write log to.
-            log_absolute: Log absolute offsets instead of relative ones to last one.
         """
-        Module.__init__(self, **kwargs)
-        PipelineMixin.__init__(self, pipeline)
+        super().__init__(steps=pipeline, **kwargs)
 
         # store
         self._camera = camera

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/pointing/acquisition.py

@@ -75,7 +75,7 @@ class Acquisition(BasePointing, CameraSettingsMixin, IAcquisition):
                      successful or not.
             broadcast: Whether to broadcast acquisition images.
         """
-        BasePointing.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
         # store
         self._default_exposure_time = exposure_time
@@ -92,9 +92,6 @@ class Acquisition(BasePointing, CameraSettingsMixin, IAcquisition):
         # init log file
         self._publisher = CsvPublisher(log_file) if log_file is not None else None
 
-        # init camera settings mixin
-        CameraSettingsMixin.__init__(self, **kwargs)
-
     async def open(self) -> None:
         """Open module"""
         await Module.open(self)

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/pointing/autoguiding.py

@@ -27,7 +27,7 @@ class AutoGuiding(BaseGuiding, CameraSettingsMixin):
             exposure_time: Initial exposure time in seconds.
             broadcast: Whether to broadcast new images.
         """
-        BaseGuiding.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
         # store
         self._default_exposure_time = exposure_time
@@ -35,9 +35,6 @@ class AutoGuiding(BaseGuiding, CameraSettingsMixin):
         self._broadcast = broadcast
         self._source_detection = SepSourceDetection()
 
-        # init camera settings mixin
-        CameraSettingsMixin.__init__(self, **kwargs)
-
         # add thread func
         self.add_background_task(self._auto_guiding)
 

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/robotic/scheduler.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import json
 import logging
 import time
@@ -19,6 +20,7 @@ from pyobs.events import (
 from pyobs.interfaces import IRunnable, IRunning, IStartStop
 from pyobs.interfaces.IRunning import RunningState
 from pyobs.modules import Module
+from pyobs.object import get_class_from_string
 from pyobs.robotic import (
     ObservationArchive,
     ObservationList,
@@ -32,6 +34,38 @@ from pyobs.utils.time import Time
 log = logging.getLogger(__name__)
 
 
+def _class_accepts_param(config: dict[str, Any] | Any, param_name: str) -> bool:
+    """Whether the class configured in `config` (a dict with a "class" key, or an already-built
+    object) declares `param_name` somewhere in its __init__ MRO.
+
+    Used to decide whether a kwarg can be injected into a child object's config -- injecting
+    unconditionally relies on the target silently absorbing it if unwanted, which no longer
+    happens now that Object.__init__ forwards leftover kwargs on to object.__init__().
+    """
+    if isinstance(config, dict):
+        if "class" not in config:
+            return False
+        try:
+            klass = get_class_from_string(config["class"])
+        except Exception:
+            return False
+    elif isinstance(config, type):
+        klass = config
+    else:
+        klass = type(config)
+    for cls in klass.__mro__:
+        init = cls.__dict__.get("__init__")
+        if init is None:
+            continue
+        try:
+            sig = inspect.signature(init)
+        except (TypeError, ValueError):
+            continue
+        if param_name in sig.parameters:
+            return True
+    return False
+
+
 class Scheduler(Module, IStartStop, IRunnable):
     """Scheduler."""
 
@@ -68,8 +102,18 @@ class Scheduler(Module, IStartStop, IRunnable):
 
         # get scheduler
         self._task_archive = self.add_child_object(tasks, TaskArchive, on_tasks_changed=self._update_schedule)
-        self._schedule = self.add_child_object(schedule, ObservationArchive, auto_update=False)
-        self._scheduler = self.add_child_object(scheduler, TaskScheduler, observation_archive=self._schedule)
+        # BackendObservationArchive declares auto_update and gates its own polling loop on it --
+        # since we already drive updates via on_tasks_changed above, that poller must stay off.
+        # Other ObservationArchive implementations (e.g. LcoObservationArchive) don't declare it at
+        # all, so it must not be injected unconditionally.
+        extra_schedule_kwargs: dict[str, Any] = {}
+        if _class_accepts_param(schedule, "auto_update"):
+            extra_schedule_kwargs["auto_update"] = False
+        self._schedule = self.add_child_object(schedule, ObservationArchive, **extra_schedule_kwargs)
+        extra_scheduler_kwargs: dict[str, Any] = {}
+        if _class_accepts_param(scheduler, "observation_archive"):
+            extra_scheduler_kwargs["observation_archive"] = self._schedule
+        self._scheduler = self.add_child_object(scheduler, TaskScheduler, **extra_scheduler_kwargs)
 
         # store
         self._running = True

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/roof/baseroof.py

@@ -12,17 +12,14 @@ from pyobs.utils.enums import MotionStatus
 log = logging.getLogger(__name__)
 
 
-class BaseRoof(WeatherAwareMixin, MotionStatusMixin, IRoof, IFitsHeaderBefore, Module, metaclass=ABCMeta):
+class BaseRoof(Module, WeatherAwareMixin, MotionStatusMixin, IRoof, IFitsHeaderBefore, metaclass=ABCMeta):
     """Base class for roofs."""
 
     __module__ = "pyobs.modules.roof"
 
     def __init__(self, **kwargs: Any):
         """Initialize a new base roof."""
-        Module.__init__(self, **kwargs)
-
-        WeatherAwareMixin.__init__(self, **kwargs)
-        MotionStatusMixin.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
     async def open(self) -> None:
         """Open module."""

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/telescope/_dummytelescopebase.py

@@ -94,8 +94,7 @@ class _DummyTelescopeBase(
             focal_length: Focal length in mm.
             wait_secs: Wait time between slew checks in seconds.
         """
-        BaseTelescope.__init__(self, **kwargs, motion_status_interfaces=["ITelescope", "IFocuser", "IFilters"])
-        FitsNamespaceMixin.__init__(self, **kwargs)
+        super().__init__(motion_status_interfaces=["ITelescope", "IFocuser", "IFilters"], **kwargs)
 
         # telescope state
         self._position = (

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/telescope/basetelescope.py

@@ -221,7 +221,7 @@ def _ra_rate_on_sky(ra1_deg: float, ra2_deg: float, dec_deg: float, dt_seconds:
 
 
 class BaseTelescope(
-    WeatherAwareMixin, MotionStatusMixin, WaitForMotionMixin, ITelescope, IFitsHeaderBefore, Module, metaclass=ABCMeta
+    Module, WeatherAwareMixin, MotionStatusMixin, WaitForMotionMixin, ITelescope, IFitsHeaderBefore, metaclass=ABCMeta
 ):
     """Base class for telescopes."""
 
@@ -241,7 +241,16 @@ class BaseTelescope(
             min_altitude: Minimal altitude for telescope.
             wait_for_dome: Name of dome module to wait for.
         """
-        Module.__init__(self, **kwargs)
+        # wait_for_dome is BaseTelescope's own param, but WaitForMotionMixin (further down the
+        # cooperative chain) needs it translated into its own wait_for_modules/wait_for_timeout/
+        # wait_for_states shape -- computed here and threaded through the single super() call,
+        # since WaitForMotionMixin has no way to see wait_for_dome itself.
+        super().__init__(
+            wait_for_modules=None if wait_for_dome is None else [wait_for_dome],
+            wait_for_timeout=60000,
+            wait_for_states=[MotionStatus.POSITIONED, MotionStatus.TRACKING],
+            **kwargs,
+        )
 
         # store
         self._fits_headers = fits_headers if fits_headers is not None else {}
@@ -265,16 +274,6 @@ class BaseTelescope(
         self.add_background_task(self._celestial, True)
         self.add_background_task(self._track_refresh, True)
 
-        # init mixins
-        WeatherAwareMixin.__init__(self, **kwargs)
-        MotionStatusMixin.__init__(self, **kwargs)
-        WaitForMotionMixin.__init__(
-            self,
-            wait_for_modules=None if wait_for_dome is None else [wait_for_dome],
-            wait_for_timeout=60000,
-            wait_for_states=[MotionStatus.POSITIONED, MotionStatus.TRACKING],
-        )
-
         # register exception
         self._register_exception(exc.MotionError, 3, timespan=600, callback=self._default_remote_error_callback)
 

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/modules/utils/dummymode.py

@@ -14,15 +14,14 @@ from pyobs.utils.enums import MotionStatus
 log = logging.getLogger(__name__)
 
 
-class DummyMode(MotionStatusMixin, Module, IMode, IMotion):
+class DummyMode(Module, MotionStatusMixin, IMode, IMotion):
     """A dummy module for mode switching."""
 
     __module__ = "pyobs.modules.utils"
 
     def __init__(self, **kwargs: Any):
         """Initialize a new dummy module."""
-        Module.__init__(self, **kwargs)
-        MotionStatusMixin.__init__(self, **kwargs)
+        super().__init__(**kwargs)
 
         # modes
         self._mode_options = {

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/object.py

@@ -355,6 +355,11 @@ class Object(PrivateAttrMixin):
         # background tasks
         self._background_tasks: list[tuple[BackgroundTask, bool]] = []
 
+        # forward anything left to the next class in the MRO -- lets mixins listed after this
+        # one in a subclass's bases (e.g. WeatherAwareMixin, PipelineMixin) claim their own
+        # kwargs cooperatively, instead of Object silently absorbing them
+        super().__init__(**kwargs)
+
     def add_background_task(
         self, func: Callable[..., Coroutine[Any, Any, None]], restart: bool = True, autostart: bool = True
     ) -> BackgroundTask:

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/utils/gui/camera/windowingwidget.py

@@ -50,7 +50,7 @@ class WindowingWidget(QtWidgets.QGroupBox):
 
     @property
     def value_top(self) -> int:
-        return self.spin_left.value()
+        return self.spin_top.value()
 
     @property
     def value_width(self) -> int:

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyobs/utils/pipeline/pipeline.py

@@ -36,8 +36,7 @@ class Pipeline(Object, PipelineMixin):
                 Calibration) and don't already specify their own. See
                 PipelineMixin.__init__.
         """
-        Object.__init__(self, **kwargs)
-        PipelineMixin.__init__(self, steps, archive=archive)
+        super().__init__(steps=steps, archive=archive, **kwargs)
 
     @staticmethod
     def _combine_calib_images(

{pyobs_core-2.0.0.dev80 → pyobs_core-2.0.0.dev82}/pyproject.toml

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