pyobs-gui 2.0.0.dev4__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.dev4 → pyobs_gui-2.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-gui
-Version: 2.0.0.dev4
+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.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.dev4 → 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 {}

pyobs_gui-2.0.0.dev5/pyobs_gui/login.py

@@ -0,0 +1,64 @@
+"""Async factory for pyobs.application.Application's module_factory contract -- see
+specs/plans/gui-interactive-login.md and specs/plans/gui-login-window.md.
+
+Shows LoginWindow, waits for Connect, then builds an XmppComm + GUI from the result. Runs inside
+the already-running event loop (see Application._main()), so it can await anything it needs to
+before the module/comm connection exists at all.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from pyobs.comm.xmpp import XmppComm
+
+from .gui import GUI
+from .loginwindow import LoginWindow
+
+log = logging.getLogger(__name__)
+
+
+async def show_login_and_connect() -> XmppComm:
+    """Shows the login window, waits for the user to click Connect (or raises
+    asyncio.CancelledError if they close the window instead -- see LoginWindow.closeEvent), then
+    returns a fresh XmppComm built from the result.
+
+    Used both for the initial standalone startup (login_and_build_gui) and for GUI's "Log out"
+    flow (GUI._logout), which shows this same window again without tearing down the running
+    Application/event loop.
+    """
+    window = LoginWindow()
+    window.show()
+    try:
+        request = await window.wait_for_connect()
+    except asyncio.CancelledError:
+        log.info("Login window closed without connecting.")
+        raise
+    finally:
+        window.close()
+
+    log.info("Connecting as %s...", request.jid)
+    return XmppComm(
+        jid=request.jid,
+        password=request.password,
+        server=request.server,
+        use_tls=request.use_tls,
+        ignore_cert_errors=request.insecure_skip_tls,
+    )
+
+
+async def login_and_build_gui(**gui_kwargs: Any) -> GUI:
+    """Shows the login window, waits for the user to click Connect (or cancels if they close the
+    window instead -- see LoginWindow.closeEvent), then returns a GUI built from the result.
+
+    Args:
+        gui_kwargs: Passed through to GUI(...) (show_shell, show_events, widgets, etc.) --
+            everything except `comm`, which is built here from the login window's result.
+    """
+    comm = await show_login_and_connect()
+    return GUI(comm=comm, standalone=True, **gui_kwargs)
+
+
+__all__ = ["login_and_build_gui", "show_login_and_connect"]