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

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

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

pyobs_core-2.10.1/pyobs/interfaces/IPushNotifications.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from enum import StrEnum
+from typing import Any
+
+from .interface import Interface
+
+
+class PushNotificationType(StrEnum):
+    """Distinct alert kinds `PushNotifier` can emit, one opt-in/out toggle each.
+
+    Extensible: future kinds (bad weather, roof open, guiding lost) become new members here.
+    Stored preferences keep working across such an addition, since they are stored as the
+    enum's string values -- a kind added later simply defaults to on, and a stored value with
+    no matching member never compares equal to anything.
+    """
+
+    MODULE_ERROR = "module_error"
+    LOG_ERROR = "log_error"
+    LOG_CRITICAL = "log_critical"
+
+
+class IPushNotifications(Interface, metaclass=ABCMeta):
+    """The module accepts device registrations for push notifications."""
+
+    __module__ = "pyobs.interfaces"
+
+    @abstractmethod
+    async def register_device(self, token: str, platform: str = "android", **kwargs: Any) -> None:
+        """Register a device to receive push notifications.
+
+        Args:
+            token: FCM/APNs device token.
+            platform: Device platform ("android" or "ios"). Stored as given; only "android"
+                actually receives pushes in v1 (see specs/design/push-notification-module.md).
+        """
+        ...
+
+    @abstractmethod
+    async def set_preferences(self, types: list[PushNotificationType], **kwargs: Any) -> None:
+        """Set which notification types this caller wants to receive.
+
+        Keyed by the calling account (`sender`), not by device -- applies to every device that
+        account has registered, present and future. A caller that never calls this receives all
+        types (all-on default); calling it with an empty list opts out of everything.
+
+        Args:
+            types: Notification types the caller wants to receive.
+        """
+        ...
+
+
+__all__ = ["IPushNotifications", "PushNotificationType"]

{pyobs_core-2.9.2 → pyobs_core-2.10.1}/pyobs/interfaces/__init__.py

@@ -51,7 +51,7 @@ from .IPointingHelioprojective import HelioprojectiveState, IPointingHelioprojec
 from .IPointingOrbitalElements import IPointingOrbitalElements, OrbitalElements
 from .IPointingRaDec import IPointingRaDec, RaDecState
 from .IPointingSeries import IPointingSeries
-from .IPushNotifications import IPushNotifications
+from .IPushNotifications import IPushNotifications, PushNotificationType
 from .IReady import IReady, ReadyState
 from .IRobotic import IRobotic, RoboticState, RoboticTask
 from .IRoboticScheduler import IRoboticScheduler, SchedulerState
@@ -151,6 +151,7 @@ __all__ = [
     "RaDecState",
     "IPointingSeries",
     "IPushNotifications",
+    "PushNotificationType",
     "IReady",
     "ReadyState",
     "IRobotic",

{pyobs_core-2.9.2 → pyobs_core-2.10.1}/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.1/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.1}/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.1}/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.1}/pyobs/modules/utils/pushnotifier.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from pyobs.events import Event, LogEvent, ModuleOpenedEvent
-from pyobs.interfaces import Interface, IPushNotifications
+from pyobs.interfaces import Interface, IPushNotifications, PushNotificationType
 from pyobs.modules import Module
 from pyobs.utils.time import Time
 
@@ -21,6 +21,10 @@ _QUEUE_MAX = 200
 # Log levels that trigger a push notification.
 _ALERT_LOG_LEVELS = {"ERROR", "CRITICAL"}
 
+# All notification types, i.e. what a caller that never set a preference receives. Stored as the
+# enum's string values, matching what `set_preferences` persists.
+_ALL_TYPES = [t.value for t in PushNotificationType]
+
 # Timeout for blocking Firebase SDK calls run in a thread -- bounds the wait so a hung network
 # call can't stall the sender thread (and thus the alert queue) forever.
 _FIREBASE_CALL_TIMEOUT = 15.0
@@ -31,6 +35,7 @@ _STORAGE_FILE = "/pyobs/pushnotifier.yaml"
 
 @dataclass
 class _Alert:
+    kind: PushNotificationType
     title: str
     body: str
 
@@ -38,6 +43,9 @@ class _Alert:
 class PushNotifier(Module, IPushNotifications):
     """Relays fleet-wide module-`ERROR` state and `ERROR`/`CRITICAL` log events to mobile devices
     via Firebase Cloud Messaging (Android only in v1 -- see specs/design/push-notification-module.md).
+
+    Each caller may opt out of individual alert kinds via `set_preferences`; a caller that never
+    does receives all of them.
     """
 
     __module__ = "pyobs.modules.utils"
@@ -53,7 +61,7 @@ class PushNotifier(Module, IPushNotifications):
         Module.__init__(self, **kwargs)
 
         self._credentials_file = credentials_file
-        self._devices: dict[str, list[dict[str, Any]]] = {}
+        self._devices: dict[str, dict[str, Any]] = {}
         self._alert_queue: asyncio.Queue[_Alert] = asyncio.Queue(maxsize=_QUEUE_MAX)
         self._fcm_app: App | None = None
 
@@ -63,11 +71,16 @@ class PushNotifier(Module, IPushNotifications):
         """Open module."""
         await Module.open(self)
 
-        # load registered devices
+        # load registered devices, migrating the legacy {sender: [devices]} shape in place -- a
+        # value that is still a bare list predates per-user preferences, and gets wrapped with an
+        # absent `preferences` key, which the reader treats as "all types on".
         try:
-            self._devices = await self.vfs.read_yaml(_STORAGE_FILE)
+            raw = await self.vfs.read_yaml(_STORAGE_FILE)
         except FileNotFoundError:
-            self._devices = {}
+            raw = {}
+        self._devices = {
+            sender: ({"devices": value} if isinstance(value, list) else value) for sender, value in (raw or {}).items()
+        }
 
         # init Firebase
         await self._init_firebase()
@@ -152,7 +165,11 @@ class PushNotifier(Module, IPushNotifications):
         def _callback(state: Any) -> None:
             status = getattr(state, "status", None)
             if status is not None and str(status).upper() == "ERROR":
-                self._enqueue_alert(f"{module}: ERROR", f"{iface.__name__} reports an ERROR state.")
+                self._enqueue_alert(
+                    PushNotificationType.MODULE_ERROR,
+                    f"{module}: ERROR",
+                    f"{iface.__name__} reports an ERROR state.",
+                )
 
         return _callback
 
@@ -182,36 +199,39 @@ class PushNotifier(Module, IPushNotifications):
         if entry.level not in _ALERT_LOG_LEVELS:
             return False
 
-        self._enqueue_alert(f"{sender}: {entry.level}", entry.message)
+        kind = PushNotificationType.LOG_CRITICAL if entry.level == "CRITICAL" else PushNotificationType.LOG_ERROR
+        self._enqueue_alert(kind, f"{sender}: {entry.level}", entry.message)
         return True
 
-    def _enqueue_alert(self, title: str, body: str) -> None:
+    def _enqueue_alert(self, kind: PushNotificationType, title: str, body: str) -> None:
         """Queue an alert for sending, dropping it if the queue is full.
 
         Args:
+            kind: Notification type of the alert.
             title: Alert title.
             body: Alert body.
         """
         if self._alert_queue.full():
             log.warning("Push notification queue full, dropping alert.")
             return
-        self._alert_queue.put_nowait(_Alert(title=title, body=body))
+        self._alert_queue.put_nowait(_Alert(kind=kind, title=title, body=body))
 
     async def _sender_thread(self) -> None:
         """Drain the alert queue and send notifications one at a time.
 
-        Consecutive duplicate alerts (same title and body) are suppressed, since one fixed rule
-        set applies fleet-wide -- every registered device gets the exact same alert, so a single
-        global dedup (rather than Telegram's per-user one) is enough.
+        Consecutive duplicate alerts (same kind, title and body) are suppressed. A single global
+        dedup (rather than Telegram's per-user one) is enough: for stable preferences a given
+        alert always targets the same recipient subset, so anyone who would receive a repeat
+        already received the original.
         """
-        last: tuple[str, str] | None = None
+        last: tuple[PushNotificationType, str, str] | None = None
         repeat_count = 0
 
         while True:
             alert = await self._alert_queue.get()
 
             try:
-                key = (alert.title, alert.body)
+                key = (alert.kind, alert.title, alert.body)
                 if key == last:
                     repeat_count += 1
                     continue
@@ -229,8 +249,18 @@ class PushNotifier(Module, IPushNotifications):
             finally:
                 self._alert_queue.task_done()
 
+    @staticmethod
+    def _wants(entry: dict[str, Any], kind: PushNotificationType) -> bool:
+        """Whether the user an entry belongs to wants the given notification kind.
+
+        An entry with no `preferences` key at all (never set, or migrated from the legacy storage
+        shape) receives everything; an explicitly empty list means opted out of all kinds.
+        """
+        prefs = entry.get("preferences")
+        return kind.value in (_ALL_TYPES if prefs is None else prefs)
+
     async def _send_to_all_devices(self, alert: _Alert) -> None:
-        """Send an alert to every registered Android device.
+        """Send an alert to every registered Android device whose owner wants this kind.
 
         Args:
             alert: The alert to send.
@@ -240,9 +270,9 @@ class PushNotifier(Module, IPushNotifications):
 
         tokens = [
             device["token"]
-            for devices in self._devices.values()
-            for device in devices
-            if device.get("platform", "android") == "android"
+            for entry in self._devices.values()
+            for device in entry.get("devices", [])
+            if device.get("platform", "android") == "android" and self._wants(entry, alert.kind)
         ]
         if not tokens:
             return
@@ -276,11 +306,25 @@ class PushNotifier(Module, IPushNotifications):
         """
         sender = kwargs.get("sender", "")
 
-        devices = self._devices.setdefault(sender, [])
+        entry = self._devices.setdefault(sender, {"devices": []})
+        devices = entry.setdefault("devices", [])
         devices[:] = [d for d in devices if d.get("token") != token]
         devices.append({"token": token, "platform": platform, "registered_at": Time.now().isot})
 
         await self.vfs.write_yaml(_STORAGE_FILE, self._devices)
 
+    async def set_preferences(self, types: list[PushNotificationType], **kwargs: Any) -> None:
+        """Set which notification types the calling account wants to receive.
+
+        Args:
+            types: Notification types to receive; an empty list opts out of everything.
+        """
+        sender = kwargs.get("sender", "")
+
+        entry = self._devices.setdefault(sender, {"devices": []})
+        entry["preferences"] = [PushNotificationType(t).value for t in types]
+
+        await self.vfs.write_yaml(_STORAGE_FILE, self._devices)
+
 
 __all__ = ["PushNotifier"]

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

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

pyobs_core-2.9.2/pyobs/interfaces/IPushNotifications.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from abc import ABCMeta, abstractmethod
-from typing import Any
-
-from .interface import Interface
-
-
-class IPushNotifications(Interface, metaclass=ABCMeta):
-    """The module accepts device registrations for push notifications."""
-
-    __module__ = "pyobs.interfaces"
-
-    @abstractmethod
-    async def register_device(self, token: str, platform: str = "android", **kwargs: Any) -> None:
-        """Register a device to receive push notifications.
-
-        Args:
-            token: FCM/APNs device token.
-            platform: Device platform ("android" or "ios"). Stored as given; only "android"
-                actually receives pushes in v1 (see specs/design/push-notification-module.md).
-        """
-        ...
-
-
-__all__ = ["IPushNotifications"]