pyobs-gui 2.0.0.dev3__tar.gz → 2.0.0.dev5__tar.gz

pyobs_gui-2.0.0.dev5/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+
+# pyside6-deploy build output for the spikes in spike_standalone/ -- generated, not source
+spike_standalone/deployment/
+spike_standalone/*.dist/
+spike_standalone/build*.log
+spike_standalone/spike_results.txt

{pyobs_gui-2.0.0.dev3 → pyobs_gui-2.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-gui
-Version: 2.0.0.dev3
+Version: 2.0.0.dev5
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
@@ -9,10 +9,12 @@ Requires-Python: <3.14,>=3.11
 Requires-Dist: astroplan>=0.10.1
 Requires-Dist: astropy<8,>=7.0.1
 Requires-Dist: colour<0.2,>=0.1.5
+Requires-Dist: keyring<26,>=25.7.0
 Requires-Dist: matplotlib<4,>=3.10.1
-Requires-Dist: pyobs-core<3,>=2.0.0.dev28
+Requires-Dist: pyobs-core<3,>=2.0.0.dev50
 Requires-Dist: pyside6>=6.10.1
-Requires-Dist: qasync<0.28,>=0.27.1
+Requires-Dist: qasync<0.29,>=0.27.1
 Requires-Dist: qfitswidget>=0.13.1
 Requires-Dist: qtawesome<2,>=1.4.0
+Requires-Dist: secretstorage<4,>=3.5.0
 Requires-Dist: sunpy[all]>=7.0.1

pyobs_gui-2.0.0.dev5/pyobs_gui/__main__.py

@@ -0,0 +1,21 @@
+"""Standalone entry point for an interactive-login pyobs-gui -- bypasses the config-file-driven
+`pyobs` CLI entirely. This is what a compiled binary (see
+specs/plans/gui-widget-plugins-and-packaging.md) targets: no YAML config, no credentials on disk
+unless the user opts into "store password" in the login window.
+"""
+
+from __future__ import annotations
+
+from pyobs.application import Application
+
+from .gui import GUI
+from .login import login_and_build_gui
+
+
+def main() -> None:
+    app = Application(module_factory=login_and_build_gui, loop_module_class=GUI)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

pyobs_gui-2.0.0.dev5/pyobs_gui/accounts.py

@@ -0,0 +1,150 @@
+"""Saved XMPP login accounts, persisted via QSettings -- see specs/plans/gui-login-window.md.
+
+Each account has a stable internal id (a uuid4 hex string, generated in add_account()) distinct
+from its jid/label -- both are freely editable via update_account(), and the id (not jid/label) is
+what a stored password gets keyed on in the system keychain, so renaming an account never orphans
+its password. Mirrors pyobs-polaris's SavedAccountsModel, which follows the same rule for the same
+reason.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+
+from PySide6 import QtCore
+
+_ORGANIZATION = "pyobs"
+_APPLICATION = "pyobs-gui"
+
+
+@dataclass
+class Account:
+    id: str
+    jid: str
+    label: str = ""
+    host: str = ""
+    port: int = 0
+    use_tls: bool = True
+    insecure_skip_tls: bool = False
+
+    @property
+    def display_name(self) -> str:
+        return self.label if self.label else self.jid
+
+
+class SavedAccountsModel:
+    """Saved account list, persisted via QSettings. Password storage is a separate concern --
+    see login.py's use of the `keyring` package, keyed by Account.id."""
+
+    def __init__(self, settings: QtCore.QSettings | None = None) -> None:
+        self._settings = settings if settings is not None else QtCore.QSettings(_ORGANIZATION, _APPLICATION)
+
+    def list_accounts(self) -> list[Account]:
+        accounts = []
+        size = self._settings.beginReadArray("accounts")
+        try:
+            for i in range(size):
+                self._settings.setArrayIndex(i)
+                accounts.append(
+                    Account(
+                        id=str(self._settings.value("id", "")),
+                        jid=str(self._settings.value("jid", "")),
+                        label=str(self._settings.value("label", "")),
+                        host=str(self._settings.value("host", "")),
+                        port=int(self._settings.value("port", 0, type=int)),  # pyrefly: ignore [bad-argument-type]
+                        use_tls=bool(self._settings.value("use_tls", True, type=bool)),
+                        insecure_skip_tls=bool(self._settings.value("insecure_skip_tls", False, type=bool)),
+                    )
+                )
+        finally:
+            self._settings.endArray()
+        return accounts
+
+    def account_by_id(self, account_id: str) -> Account | None:
+        for account in self.list_accounts():
+            if account.id == account_id:
+                return account
+        return None
+
+    def add_account(
+        self,
+        jid: str,
+        label: str = "",
+        host: str = "",
+        port: int = 0,
+        use_tls: bool = True,
+        insecure_skip_tls: bool = False,
+    ) -> str:
+        """Adds a new account and returns its newly generated id."""
+        account = Account(
+            id=uuid.uuid4().hex,
+            jid=jid,
+            label=label,
+            host=host,
+            port=port,
+            use_tls=use_tls,
+            insecure_skip_tls=insecure_skip_tls,
+        )
+        accounts = self.list_accounts()
+        accounts.append(account)
+        self._write_all(accounts)
+        return account.id
+
+    def update_account(
+        self,
+        account_id: str,
+        jid: str,
+        label: str = "",
+        host: str = "",
+        port: int = 0,
+        use_tls: bool = True,
+        insecure_skip_tls: bool = False,
+    ) -> None:
+        """Updates an existing account's fields in place -- the id itself never changes."""
+        accounts = self.list_accounts()
+        for i, account in enumerate(accounts):
+            if account.id == account_id:
+                accounts[i] = Account(
+                    id=account_id,
+                    jid=jid,
+                    label=label,
+                    host=host,
+                    port=port,
+                    use_tls=use_tls,
+                    insecure_skip_tls=insecure_skip_tls,
+                )
+                break
+        self._write_all(accounts)
+
+    def remove_account(self, account_id: str) -> None:
+        accounts = [a for a in self.list_accounts() if a.id != account_id]
+        self._write_all(accounts)
+
+    def _write_all(self, accounts: list[Account]) -> None:
+        self._settings.beginWriteArray("accounts")
+        try:
+            for i, account in enumerate(accounts):
+                self._settings.setArrayIndex(i)
+                self._settings.setValue("id", account.id)
+                self._settings.setValue("jid", account.jid)
+                self._settings.setValue("label", account.label)
+                self._settings.setValue("host", account.host)
+                self._settings.setValue("port", account.port)
+                self._settings.setValue("use_tls", account.use_tls)
+                self._settings.setValue("insecure_skip_tls", account.insecure_skip_tls)
+        finally:
+            self._settings.endArray()
+
+    @property
+    def last_selected_account_id(self) -> str:
+        """Only remembers which account was last used (to preselect it next launch) -- never
+        implies anything was saved/connected automatically."""
+        return str(self._settings.value("last_selected_account_id", ""))
+
+    @last_selected_account_id.setter
+    def last_selected_account_id(self, value: str) -> None:
+        self._settings.setValue("last_selected_account_id", value)
+
+
+__all__ = ["Account", "SavedAccountsModel"]

{pyobs_gui-2.0.0.dev3 → pyobs_gui-2.0.0.dev5}/pyobs_gui/camerawidget.py

@@ -17,7 +17,6 @@ from pyobs.interfaces import (
     IBinning,
     BinningState,
     IWindow,
-    WindowState,
     IFilters,
     ICooling,
     ITemperatures,
@@ -58,13 +57,6 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         self.exposure_time_left = 0.0
         self.exposure_progress = 0.0
 
-        self.spinWindowLeft.init_modified(self.labelWindowLeft).committed.connect(self._window_changed)
-        self.spinWindowTop.init_modified(self.labelWindowTop).committed.connect(self._window_changed)
-        self.spinWindowWidth.init_modified(self.labelWindowWidth).committed.connect(self._window_changed)
-        self.spinWindowHeight.init_modified(self.labelWindowHeight).committed.connect(self._window_changed)
-        self.spinGain.init_modified(self.labelGain).committed.connect(self._gain_changed)
-        self.spinGainOffset.init_modified(self.labelGain).committed.connect(self._gain_changed)
-
     async def open(
         self,
         modules: list[str] | None = None,
@@ -80,7 +72,7 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         image_types = sorted([it.name for it in ImageType])
         self.comboImageType.addItems(image_types)
 
-        # before first update, disable mys
+        # before first update, disable myself
         self.setEnabled(False)
 
         # hide groups, if necessary
@@ -118,10 +110,25 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
 
     async def _init(self) -> None:
         # window
+        window_caps = await self.comm.get_capabilities(self.module, IWindow)
+        if window_caps is not None:
+            self.spinWindowLeft.setMaximum(int(window_caps.full_frame_width))
+            self.spinWindowTop.setMaximum(int(window_caps.full_frame_height))
+            self.spinWindowWidth.setMaximum(int(window_caps.full_frame_width))
+            self.spinWindowHeight.setMaximum(int(window_caps.full_frame_height))
         async with self.comm.safe_proxy(self.module, IWindow) as proxy:
             if proxy is not None:
-                await self.comm.subscribe_state(self.module, IWindow, self._update_window)
-                await self.set_full_frame()
+                state = await proxy.wait_for_state(IWindow)
+                if state is not None:
+                    self.spinWindowLeft.setValue(state.x)
+                    self.spinWindowTop.setValue(state.y)
+                    self.spinWindowWidth.setValue(state.width)
+                    self.spinWindowHeight.setValue(state.height)
+                elif window_caps is not None:
+                    self.spinWindowLeft.setValue(window_caps.full_frame_x)
+                    self.spinWindowTop.setValue(window_caps.full_frame_y)
+                    self.spinWindowWidth.setValue(window_caps.full_frame_width)
+                    self.spinWindowHeight.setValue(window_caps.full_frame_height)
 
         # binning
         binning_caps = await self.comm.get_capabilities(self.module, IBinning)
@@ -129,11 +136,21 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             binnings = [f"{b.x}x{b.y}" for b in binning_caps.binnings]
             self.comboBinning.clear()
             self.comboBinning.addItems(binnings)
-            await self.comm.subscribe_state(self.module, IBinning, self._update_binning)
+        async with self.comm.safe_proxy(self.module, IBinning) as proxy:
+            if proxy is not None:
+                state = await proxy.wait_for_state(IBinning)
+                if state is not None:
+                    self.comboBinning.setCurrentText(f"{state.x}x{state.y}")
+        await self.comm.subscribe_state(self.module, IBinning, self._update_binning)
 
-        # gain — initial values delivered by subscription callback
-        if await self.comm.has_proxy(self.module, IGain):
-            await self.comm.subscribe_state(self.module, IGain, self._update_gain)
+        # gain
+        async with self.comm.safe_proxy(self.module, IGain) as proxy:
+            if proxy is not None:
+                state = await proxy.wait_for_state(IGain)
+                if state is not None:
+                    self.spinGain.setValue(state.gain)
+                    self.spinGainOffset.setValue(state.offset)
+        await self.comm.subscribe_state(self.module, IGain, self._update_gain)
 
         # image format
         image_format_caps = await self.comm.get_capabilities(self.module, IImageFormat)
@@ -141,38 +158,52 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             image_formats = [ImageFormat(f) for f in image_format_caps.image_formats]
             self.comboImageFormat.clear()
             self.comboImageFormat.addItems([f.name for f in image_formats])
-            await self.comm.subscribe_state(self.module, IImageFormat, self._update_image_format)
+        async with self.comm.safe_proxy(self.module, IImageFormat) as proxy:
+            if proxy is not None:
+                state = await proxy.wait_for_state(IImageFormat)
+                if state is not None:
+                    self.comboImageFormat.setCurrentText(state.image_format.name)
+        await self.comm.subscribe_state(self.module, IImageFormat, self._update_image_format)
 
+        # image type
         async with self.comm.safe_proxy(self.module, IImageType) as proxy:
             if proxy is not None:
-                await self.comm.subscribe_state(self.module, IImageType, self._update_image_type)
+                state = await proxy.wait_for_state(IImageType)
+                if state is not None:
+                    self.comboImageType.setCurrentText(state.image_type.name)
+        await self.comm.subscribe_state(self.module, IImageType, self._update_image_type)
 
+        # exposure (status, progress, time left)
         async with self.comm.safe_proxy(self.module, IExposure) as proxy:
             if proxy is not None:
-                await self.comm.subscribe_state(self.module, IExposure, self._update_exposure)
-
+                state = await proxy.wait_for_state(IExposure)
+                if state is not None:
+                    self.exposure_status = state.status
+                    self.exposure_progress = state.progress
+                    self.exposure_time_left = state.exposure_time_left
+        await self.comm.subscribe_state(self.module, IExposure, self._update_exposure)
+
+        # exposure time
         async with self.comm.safe_proxy(self.module, IExposureTime) as proxy:
             if proxy is not None:
-                await self.comm.subscribe_state(self.module, IExposureTime, self._update_exposure_time)
+                state = await proxy.wait_for_state(IExposureTime)
+                if state is not None:
+                    self.spinExpTime.setValue(state.exposure_time)
+        await self.comm.subscribe_state(self.module, IExposureTime, self._update_exposure_time)
 
+        # data sequence
         if await self.comm.has_proxy(self.module, IDataSequence):
             await self.comm.subscribe_state(self.module, IDataSequence, self._update_sequence)
 
         # update GUI
         self.signal_update_gui.emit()
 
-    def _update_window(self, state: WindowState):
-        self.labelWindowLeft.setText(str(state.x))
-        self.labelWindowTop.setText(str(state.y))
-        self.labelWindowWidth.setText(str(state.width))
-        self.labelWindowHeight.setText(str(state.height))
-
     def _update_binning(self, state: BinningState):
         self.comboBinning.setCurrentText(f"{state.x}x{state.y}")
 
     def _update_gain(self, state: GainState):
-        self.labelGain.setText(str(state.gain))
-        self.labelGainOffset.setText(str(state.offset))
+        self.spinGain.setValue(state.gain)
+        self.spinGainOffset.setValue(state.offset)
 
     def _update_image_format(self, state: ImageFormatState):
         self.comboImageFormat.setCurrentText(state.image_format.name)
@@ -194,14 +225,6 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         self.exposures_left = state.count_left
         self.update_gui()
 
-    @qasync.asyncSlot()
-    async def _window_changed(self):
-        print("ok")
-
-    @qasync.asyncSlot()
-    async def _gain_changed(self):
-        print("ok")
-
     @qasync.asyncSlot()  # type: ignore
     async def set_full_frame(self) -> None:
         caps = await self.comm.get_capabilities(self.module, IWindow)
@@ -247,18 +270,75 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
 
     @qasync.asyncSlot()  # type: ignore
     async def expose(self) -> None:
+        # set binning
+        async with self.comm.safe_proxy(self.module, IBinning) as proxy:
+            if proxy is not None:
+                binning = int(self.comboBinning.currentText()[0])
+                try:
+                    await proxy.set_binning(binning, binning)
+                except Exception:
+                    log.exception("bla")
+                    QtWidgets.QMessageBox.information(self, "Error", "Could not set binning.")
+                    return
+            else:
+                binning = 1
+
+        # set window
+        async with self.comm.safe_proxy(self.module, IWindow) as proxy:
+            if proxy is not None:
+                left, top = self.spinWindowLeft.value(), self.spinWindowTop.value()
+                width, height = self.spinWindowWidth.value(), self.spinWindowHeight.value()
+                try:
+                    await proxy.set_window(left, top, width * binning, height * binning)
+                except Exception:
+                    QtWidgets.QMessageBox.information(self, "Error", "Could not set window.")
+                    return
+
+        # set image format
+        async with self.comm.safe_proxy(self.module, IImageFormat) as proxy:
+            if proxy is not None:
+                image_format = ImageFormat[self.comboImageFormat.currentText()]
+                await proxy.set_image_format(image_format)
+
+        # set exposure time
+        async with self.comm.safe_proxy(self.module, IExposureTime) as proxy:
+            if proxy is not None:
+                # get exp_time
+                exp_time = self.spinExpTime.value()
+
+                # unit
+                if self.comboExpTimeUnit.currentText() == "ms":
+                    exp_time /= 1e3
+                elif self.comboExpTimeUnit.currentText() == "µs":
+                    exp_time /= 1e6
+
+                # set it
+                await proxy.set_exposure_time(exp_time)
+
+        # set gain and offset
+        async with self.comm.safe_proxy(self.module, IGain) as proxy:
+            if proxy is not None:
+                await proxy.set_gain(self.spinGain.value())
+                await proxy.set_offset(self.spinGainOffset.value())
+
+        # set image type
+        image_type = ImageType.OBJECT
+        async with self.comm.safe_proxy(self.module, IImageType) as proxy:
+            if proxy is not None:
+                image_type = ImageType(self.comboImageType.currentText().lower())
+                await proxy.set_image_type(image_type)
+
+        # set initial image count
+        self.exposures_left = self.spinCount.value()
         broadcast = self.checkBroadcast.isChecked()
-        count = self.spinCount.value()
 
-        # if the module can grab a counted sequence server-side, let it -- progress comes
-        # back via the DataSequenceState subscription
+        # if the module can grab a counted sequence server-side, let it
         async with self.comm.safe_proxy(self.module, IDataSequence) as proxy:
             if proxy is not None:
-                await proxy.grab_sequence(count, broadcast)
+                await proxy.grab_sequence(self.exposures_left, broadcast)
                 return
 
         # fall back to a client-side loop for modules that don't support IDataSequence
-        self.exposures_left = count
         while self.exposures_left > 0:
             await self.datadisplay.grab_data(broadcast)
             self.exposures_left -= 1

{pyobs_gui-2.0.0.dev3 → pyobs_gui-2.0.0.dev5}/pyobs_gui/compassmovewidget.py

@@ -46,7 +46,9 @@ class CompassMoveWidget(BaseWidget, Ui_CompassMoveWidget):
             if altaz_state is None:
                 return
             altaz = SkyCoord(
+                # pyrefly: ignore [missing-attribute]
                 alt=altaz_state.alt * u.degree,
+                # pyrefly: ignore [missing-attribute]
                 az=altaz_state.az * u.degree,
                 obstime=Time.now(),
                 location=self.observer.location,

pyobs_gui-2.0.0.dev5/pyobs_gui/gui.py

@@ -0,0 +1,173 @@
+import asyncio
+import logging
+import sys
+from typing import Any, cast, TYPE_CHECKING
+from PySide6 import QtWidgets  # type: ignore
+import qasync  # type: ignore
+
+if TYPE_CHECKING:
+    from .mainwindow import MainWindow
+
+from pyobs.interfaces import FitsHeaderEntry, IFitsHeaderBefore
+from pyobs.modules import Module
+
+from .utils import QAsyncMessageBox
+
+log = logging.getLogger(__name__)
+
+
+class GUI(Module, IFitsHeaderBefore):
+    __module__ = "pyobs_gui"
+
+    app: QtWidgets.QApplication | None = None
+
+    def __init__(
+        self,
+        show_shell: bool = True,
+        show_events: bool = True,
+        show_status: bool = True,
+        show_modules: list[str] | None = None,
+        widgets: list[dict[str, Any]] | None = None,
+        sidebar: list[dict[str, Any]] | None = None,
+        standalone: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        """Inits a new GUI.
+
+        Args:
+            show_shell: Whether to show the shell page.
+            show_events: Whether to show the events page.
+            show_modules: If not empty, show only listed modules.
+            widgets: List of custom widgets.
+            sidebar: List of custom sidebar widgets.
+            standalone: Whether this GUI was built by the interactive login window
+                (pyobs_gui.login.login_and_build_gui) rather than a YAML-configured Comm. When
+                True, MainWindow's bottom-left button reads "Log out" and reconnects via the
+                login window instead of quitting the whole app.
+        """
+
+        # init module
+        Module.__init__(self, *args, **kwargs)
+        self._window: MainWindow | None = None
+        self._show_shell = show_shell
+        self._show_events = show_events
+        self._show_status = show_status
+        self._show_modules = show_modules
+        self._custom_widgets = widgets
+        self._custom_sidebar_widgets = sidebar
+        self._standalone = standalone
+        self._logging_out = False
+
+    @staticmethod
+    def new_event_loop() -> asyncio.AbstractEventLoop:
+        GUI.app = QtWidgets.QApplication(sys.argv)
+        # standalone/login mode briefly has zero visible top-level windows while the login
+        # dialog closes and the (old or new) MainWindow hasn't opened yet -- Qt's default
+        # "quit when the last window closes" would tear down the whole event loop right there,
+        # so this app manages its own lifetime exclusively through Module.quit() instead.
+        GUI.app.setQuitOnLastWindowClosed(False)
+        return cast("asyncio.AbstractEventLoop", qasync.QEventLoop(GUI.app))
+
+    async def open(self) -> None:
+        """Open module."""
+        from .mainwindow import MainWindow
+
+        await Module.open(self)
+
+        # create and show window
+        self._window = MainWindow(
+            show_shell=self._show_shell,
+            show_events=self._show_events,
+            show_status=self._show_status,
+            show_modules=self._show_modules,
+            widgets=self._custom_widgets,
+            sidebar=self._custom_sidebar_widgets,
+            on_logout=self._request_logout if self._standalone else None,
+        )
+        await self._window.open(
+            module=self,
+            comm=self.comm,
+            vfs=self.vfs,
+            observer=self._observer,
+        )
+        self._window.show()
+
+    def _request_logout(self) -> None:
+        """Wired to MainWindow's "Log out" button (standalone mode only). Hides the current
+        window immediately -- like a real logout, not a "maybe" -- then schedules the async part
+        (unregistering its widgets' comm subscriptions, closing the comm, showing the login
+        window again) as a background task, since Qt click handlers are synchronous.
+        """
+        if self._logging_out:
+            return  # already logging out -- ignore a repeat click
+        self._logging_out = True
+
+        old_window = self._window
+        self._window = None
+        if old_window is not None:
+            old_window.close_for_logout()
+
+        asyncio.create_task(self._logout(old_window))
+
+    async def _logout(self, old_window: "MainWindow | None") -> None:
+        """Closes the current comm, then shows the login window and reconnects with whatever it
+        resolves to -- all within the same running Application/event loop, so Ctrl+C and the
+        eventual real "Quit" still reach this exact module instance (see
+        specs/plans/gui-login-window.md for why a brand new GUI() instance would leave
+        Application's own bookkeeping stale instead).
+
+        By the time this runs, MainWindow._request_logout() has already hidden the old window --
+        there's no session left to fall back to, so any failure here (the user closes the login
+        window without connecting, or the reconnect itself fails) is reported via an error dialog
+        and the app then quits cleanly, rather than limping on with no window and no comm.
+        """
+        if old_window is not None:
+            # must happen before deleteLater(): unregisters every widget's comm subscriptions
+            # first, so a stray in-flight callback can't fire against an already-destroyed label
+            await old_window.discard_all_widgets()
+            old_window.deleteLater()
+
+        old_comm = self._comm
+        if old_comm is not None:
+            await old_comm.close()
+
+        from .login import show_login_and_connect
+
+        try:
+            new_comm = await show_login_and_connect()
+        except asyncio.CancelledError:
+            log.info("Login window closed without connecting; nothing left to do but quit.")
+            self.quit()
+            return
+        except Exception as e:
+            log.exception("Could not build a new connection.")
+            await QAsyncMessageBox.critical(None, "Log out", f"Could not reconnect: {e}\n\nClosing the app.")
+            self.quit()
+            return
+        finally:
+            self._logging_out = False
+
+        self._comm = new_comm
+        try:
+            await self.startup()
+        except Exception as e:
+            log.exception("Reconnecting with the new account failed.")
+            await QAsyncMessageBox.critical(None, "Log out", f"Could not reconnect: {e}\n\nClosing the app.")
+            self.quit()
+
+    async def get_fits_header_before(
+        self, namespaces: list[str] | None = None, **kwargs: Any
+    ) -> dict[str, FitsHeaderEntry]:
+        """Returns FITS header for the current status of this module.
+
+        Args:
+            namespaces: If given, only return FITS headers for the given namespaces.
+
+        Returns:
+            Dictionary containing FITS headers.
+        """
+        if self._window is not None:
+            return self._window.get_fits_headers(namespaces)
+        else:
+            return {}