pyobs-gui 2.5.2__tar.gz → 2.6.0__tar.gz

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-gui
-Version: 2.5.2
+Version: 2.6.0
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
@@ -8,13 +8,19 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: astroplan>=0.10.1
 Requires-Dist: astropy<8,>=7.0.1
+Requires-Dist: astroquery<0.5,>=0.4.10
 Requires-Dist: colour<0.2,>=0.1.5
+Requires-Dist: desktop-notifier<7,>=6.2
 Requires-Dist: keyring<26,>=25.7.0
 Requires-Dist: matplotlib<4,>=3.10.1
-Requires-Dist: pyobs-core<3,>=2.7.2
-Requires-Dist: pyside6>=6.10.1
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pydantic<3,>=2.12.5
+Requires-Dist: pyobs-core<3,>=2.13.5
+Requires-Dist: pyside6-essentials>=6.10.1
+Requires-Dist: pywin32>=312; sys_platform == 'win32'
+Requires-Dist: pyyaml<7,>=6.0.2
 Requires-Dist: qasync<0.29,>=0.27.1
-Requires-Dist: qfitswidget>=1.1.3
+Requires-Dist: qfitswidget>=1.2.0
 Requires-Dist: qtawesome<2,>=1.4.0
 Requires-Dist: secretstorage<4,>=3.5.0
-Requires-Dist: sunpy[all]>=7.0.1
+Requires-Dist: sunpy>=7.0.1

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/docs/source/index.rst

@@ -44,6 +44,63 @@ This is an example configuration for a GUI that defines one custom widget for th
           download: http://localhost:37077/
 
 
+Settings and desktop notifications
+***********************************
+
+The GUI can show a desktop notification when a module goes into ``ERROR`` or when an ``ERROR`` or
+``CRITICAL`` log event arrives, so an operator who has the GUI open but is not looking at it notices.
+No tray icon is needed. Notifications are only shown while the GUI is not the active application.
+Clicking one brings the window forward (where the desktop allows it, otherwise it is highlighted in
+the taskbar) and, for a module error, selects that module.
+
+Configured GUI (YAML)
+=====================
+
+Notifications are **off** unless the configuration has a ``notifications:`` block. With the block
+present they are on, and these values can be set (all optional, shown with their defaults)::
+
+    class: pyobs_gui.GUI
+
+    notifications:
+      enabled: true
+      min_log_level: ERROR        # ERROR or CRITICAL
+      only_when_inactive: true    # nothing while the GUI is the active application
+      muted_modules: []           # modules that never notify
+      rate_limit: 10              # seconds, repeats from one module are combined into "N more"
+
+A typo in the block is an error at startup. At most 5 notifications are shown in 30 seconds, the rest
+is combined into one "+N more notifications". Modules that are already in ``ERROR`` when the GUI
+connects are announced together in one notification.
+
+Standalone GUI (login window)
+=============================
+
+The standalone GUI has a **Settings** button above "Log out". The settings are saved per account in
+``settings.yaml`` in the user's config directory (``~/.config/pyobs/pyobs-gui/`` on Linux) and apply
+immediately. There are two tabs:
+
+* *Notifications*: the values above, plus **Send test notification**, which shows whether the desktop
+  shows notifications at all.
+* *VFS*: the VFS roots, which the standalone GUI otherwise does not have. Without a root for the
+  path a camera publishes, images and the live view cannot be loaded. A root has a name, a class
+  (e.g. ``pyobs.vfs.HttpFile``) and parameters as YAML, the same as in a ``vfs:`` block.
+
+The file can contain tokens in clear text, so it is only readable by the user (on systems that have
+such permissions). A file that cannot be read is never overwritten: fix or delete it.
+
+If nothing appears
+==================
+
+Use the test button first. It reports an error if the system refuses, and says what to check if it
+does not. Notifications were checked on KDE Plasma and GNOME (Wayland) and on Windows 11, not yet on
+macOS.
+
+* On every system, check that Do Not Disturb (Focus Assist on Windows) is off.
+* Windows shows a notification only for an app that has an entry in the Start Menu. pyobs-gui creates
+  ``pyobs-gui`` there when it first sends a notification. Windows gives no error when it drops a
+  notification, so if the entry was deleted, restart the GUI.
+* macOS asks for permission once. If it was refused, allow it for pyobs-gui in System Settings.
+
 Available classes
 ******************
 

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/pyobs_gui/__init__.py

@@ -4,6 +4,13 @@ TODO: write doc
 
 __title__ = "GUI"
 
+# pydantic loads its submodules lazily. If that first happens after PySide6 was imported, PySide6's
+# import hook (shibokensupport.feature) trips over it: "cannot import name 'import_string' ...
+# circular import". The `pyobs` command imports pydantic through pyobs-core before it imports this
+# package, but only partly, so what this package uses from pydantic is loaded here, before anything
+# imports PySide6 (see tests/test_import_order.py).
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator  # noqa: E402, F401
+
 from ._nuitka_astropy_patch import patch_generic_unit_parser
 
 # Only relevant in the Nuitka-compiled standalone binary: under a regular interpreter the

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/pyobs_gui/base.py

@@ -45,6 +45,20 @@ async def show_remote_error(parent: QtWidgets.QWidget, exception: Exception) ->
         await QAsyncMessageBox.warning(parent, "Error", str(exception))
 
 
+def missing_root_message(exception: Exception, path: str, module: str) -> str | None:
+    """User-facing text if `exception` is the VFS's "unknown root" error, else None.
+
+    `VirtualFileSystem.open_file()` raises a plain `ValueError("Could not find root ...")`, so the
+    message prefix is the only way to tell it from other `ValueError`s.
+    """
+    from pyobs.vfs import VirtualFileSystem
+
+    if not isinstance(exception, ValueError) or not str(exception).startswith("Could not find root"):
+        return None
+    root, _ = VirtualFileSystem.split_root(path)
+    return f"Cannot open '{path}' from module '{module}': the VFS root '{root}' is not configured."
+
+
 async def cancel_and_drain(task: asyncio.Task[Any]) -> None:
     """Cancel a task and await its unwind, swallowing the resulting CancelledError."""
     task.cancel()
@@ -344,7 +358,11 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         self._init_steps_done.add(key)
 
     def hideEvent(self, event: QtGui.QHideEvent) -> None:
-        # run in loop
+        # run in loop (at shutdown Qt still hides widgets after the loop has stopped, nothing to cancel then)
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return
         asyncio.create_task(self._hide_event(event))
 
     async def _hide_event(self, event: QtGui.QHideEvent) -> None:

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/pyobs_gui/datadisplaywidget.py

@@ -15,7 +15,8 @@ from qfitswidget import QFitsWidget  # type: ignore
 from pyobs.events import NewImageEvent, NewSpectrumEvent, Event
 from pyobs.interfaces import IData, ISpectrograph
 from pyobs.vfs import VirtualFileSystem
-from .base import BaseWidget
+from .base import BaseWidget, missing_root_message
+from .utils import QAsyncMessageBox
 from .qt.datadisplaywidget_ui import Ui_DataDisplayWidget
 
 if TYPE_CHECKING:
@@ -43,6 +44,8 @@ class DataDisplayWidget(BaseWidget, Ui_DataDisplayWidget):
         self.canvas: FigureCanvas | None = None
         self.plotTools: NavigationToolbar2QT | None = None
         self.is_spectrograph = False
+        # roots already reported to the user, so a stream of images doesn't open one box each
+        self._reported_roots: set[str] = set()
 
         # before first update, disable mys
         self.setEnabled(False)
@@ -101,6 +104,15 @@ class DataDisplayWidget(BaseWidget, Ui_DataDisplayWidget):
         # signal GUI update
         self.signal_update_gui.emit()
 
+    async def _report_missing_root(self, path: str, message: str) -> None:
+        """Log every time, but open the message box only once per root."""
+        log.error(message)
+        root = VirtualFileSystem.split_root(path)[0]
+        if root in self._reported_roots:
+            return
+        self._reported_roots.add(root)
+        await QAsyncMessageBox.warning(self, "VFS root not configured", message)
+
     def plot(self) -> None:
         """Show data."""
         if self.data is None:
@@ -198,7 +210,14 @@ class DataDisplayWidget(BaseWidget, Ui_DataDisplayWidget):
         # download data
         if self.vfs is None or not isinstance(self.vfs, VirtualFileSystem):
             return False
-        data = await self.vfs.read_fits(event.filename)
+        try:
+            data = await self.vfs.read_fits(event.filename)
+        except ValueError as e:
+            message = missing_root_message(e, event.filename, self.module)
+            if message is None:
+                raise
+            await self._report_missing_root(event.filename, message)
+            return False
 
         # auto save?
         if autosave is not None:

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/pyobs_gui/gui.py

@@ -1,4 +1,5 @@
 import asyncio
+from functools import partial
 import logging
 import sys
 from typing import Any, cast, TYPE_CHECKING
@@ -12,6 +13,12 @@ from pyobs.interfaces import FitsHeaderEntry, IFitsHeaderBefore
 from pyobs.modules import Module
 
 from .nowheelfilter import NoWheelWhenUnfocused
+from .guisignals import gui_signals
+from .notificationmanager import NotificationManager
+from .notifier import GuardedNotifier
+from .notifier_backend import DesktopNotifierBackend
+from .settings import GuiSettings, NotificationSettings, SettingsError, SettingsStore, unknown_keys
+from .settingsdialog import SettingsDialog
 from .utils import QAsyncMessageBox
 
 log = logging.getLogger(__name__)
@@ -34,6 +41,8 @@ class GUI(Module, IFitsHeaderBefore):
         widgets: list[dict[str, Any]] | None = None,
         sidebar: list[dict[str, Any]] | None = None,
         standalone: bool = False,
+        notifications: dict[str, Any] | None = None,
+        settings_key: str | None = None,
         *args: Any,
         **kwargs: Any,
     ):
@@ -49,10 +58,28 @@ class GUI(Module, IFitsHeaderBefore):
                 (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.
+            notifications: Notification settings, see `NotificationSettings`. Unknown keys are
+                rejected, so a typo in the YAML doesn't silently do nothing.
+            settings_key: Standalone only: key of this connection's settings in the settings file
+                (see `login.settings_key`). The settings then come from that file and can be
+                edited with the settings dialog, `notifications` is not used.
         """
 
+        unknown = unknown_keys(NotificationSettings, notifications or {}, "notifications.")
+        if unknown:
+            raise ValueError(f"Unknown GUI settings: {', '.join(unknown)}")
+        # YAML mode: off unless the config has a `notifications:` block, so existing control-room GUIs
+        # don't start showing desktop notifications after an upgrade
+        notification_settings = (
+            NotificationSettings.model_validate(notifications)
+            if notifications is not None
+            else NotificationSettings(enabled=False)
+        )
+        settings = GuiSettings(notifications=notification_settings)
+
         # init module
         Module.__init__(self, *args, **kwargs)
+        self.settings = settings
         self._window: MainWindow | None = None
         self._show_shell = show_shell
         self._show_events = show_events
@@ -63,6 +90,60 @@ class GUI(Module, IFitsHeaderBefore):
         self._standalone = standalone
         self._logging_out = False
 
+        # standalone: settings live in a file, per connection
+        self._settings_key = settings_key
+        self._store: SettingsStore | None = SettingsStore() if standalone and settings_key else None
+        self._settings_dialog: SettingsDialog | None = None
+        self._notifications: NotificationManager | None = None
+        self._notifier_backend: DesktopNotifierBackend | None = None
+        if self._store is not None and settings_key is not None:
+            self.settings = self._load_settings(settings_key)
+
+    def _load_settings(self, key: str) -> GuiSettings:
+        """Settings from the file. An unreadable file must not keep the GUI from starting, so
+        that falls back to the defaults (saving then fails with the same error, rather than
+        overwriting the file)."""
+        assert self._store is not None
+        try:
+            return self._store.get(key)
+        except SettingsError:
+            log.exception("Could not load settings, using defaults.")
+            return GuiSettings()
+
+    def _apply_vfs_roots(self) -> None:
+        if self._store is not None:
+            self.vfs.set_roots(self.settings.vfs.roots)
+
+    def apply_settings(self, settings: GuiSettings) -> None:
+        """Standalone only: save the settings, put them into effect and tell the widgets.
+
+        Raises:
+            SettingsError: The file couldn't be written. Nothing was changed then.
+        """
+        if self._store is None or self._settings_key is None:
+            raise RuntimeError("Settings can only be changed in standalone mode.")
+        self._store.set(self._settings_key, settings)
+        self.settings = settings
+        self._apply_vfs_roots()
+        gui_signals.settings_changed.emit()
+
+    def _open_settings(self) -> None:
+        """Wired to MainWindow's "Settings" button (standalone mode only)."""
+        if self._settings_dialog is not None:
+            self._settings_dialog.raise_()
+            self._settings_dialog.activateWindow()
+            return
+        dialog = SettingsDialog(
+            self.settings,
+            list(self.comm.clients),
+            self.apply_settings,
+            send_test=self._send_test_notification,
+            parent=self._window,
+        )
+        dialog.finished.connect(lambda _result: setattr(self, "_settings_dialog", None))
+        self._settings_dialog = dialog
+        dialog.open()
+
     @staticmethod
     def new_event_loop() -> asyncio.AbstractEventLoop:
         GUI.app = QtWidgets.QApplication(sys.argv)
@@ -80,6 +161,7 @@ class GUI(Module, IFitsHeaderBefore):
         from .mainwindow import MainWindow
 
         await Module.open(self)
+        self._apply_vfs_roots()
 
         # create and show window
         self._window = MainWindow(
@@ -90,6 +172,7 @@ class GUI(Module, IFitsHeaderBefore):
             widgets=self._custom_widgets,
             sidebar=self._custom_sidebar_widgets,
             on_logout=self._request_logout if self._standalone else None,
+            on_settings=self._open_settings if self._store is not None else None,
         )
         await self._window.open(
             module=self,
@@ -98,6 +181,54 @@ class GUI(Module, IFitsHeaderBefore):
             observer=self._observer,
         )
         self._window.show()
+        await self._start_notifications()
+
+    def _get_notifier_backend(self) -> DesktopNotifierBackend:
+        """One backend for the notifications and the test button, so the system sees one app."""
+        if self._notifier_backend is None:
+            self._notifier_backend = DesktopNotifierBackend()
+        return self._notifier_backend
+
+    async def _send_test_notification(self) -> None:
+        """The settings dialog's test button: straight through the backend, so a problem is raised
+        (as NotifierError) and the filters of the policy don't apply."""
+        await self._get_notifier_backend().send(
+            "pyobs-gui", "Desktop notifications work.", False, partial(self._bring_window_to_front, None)
+        )
+
+    async def _start_notifications(self) -> None:
+        """Desktop notifications for module errors. A problem here must not keep the GUI from starting."""
+        backend = self._get_notifier_backend()
+        manager = NotificationManager(
+            comm=self.comm,
+            settings=lambda: self.settings.notifications,
+            notifier=GuardedNotifier(backend),
+            bring_to_front=self._bring_window_to_front,
+            authorise=backend.ensure_authorisation,
+        )
+        try:
+            await manager.start(self.comm.clients)
+        except Exception:
+            log.warning("Could not start desktop notifications.", exc_info=True)
+            return
+        self._notifications = manager
+
+    async def _close_notifications(self) -> None:
+        manager, self._notifications = self._notifications, None
+        if manager is not None:
+            try:
+                await manager.close()
+            except Exception:
+                log.warning("Could not stop desktop notifications cleanly.", exc_info=True)
+
+    def _bring_window_to_front(self, module: str | None) -> None:
+        if self._window is not None:
+            self._window.bring_to_front(module)
+
+    async def close(self) -> None:
+        """Close module."""
+        await self._close_notifications()
+        await Module.close(self)
 
     def _request_logout(self) -> None:
         """Wired to MainWindow's "Log out" button (standalone mode only). Hides the current
@@ -109,6 +240,8 @@ class GUI(Module, IFitsHeaderBefore):
             return  # already logging out -- ignore a repeat click
         self._logging_out = True
 
+        if self._settings_dialog is not None:
+            self._settings_dialog.close()
         old_window = self._window
         self._window = None
         if old_window is not None:
@@ -134,6 +267,8 @@ class GUI(Module, IFitsHeaderBefore):
             await old_window.discard_all_widgets()
             old_window.deleteLater()
 
+        await self._close_notifications()
+
         old_comm = self._comm
         if old_comm is not None:
             await old_comm.close()
@@ -141,7 +276,7 @@ class GUI(Module, IFitsHeaderBefore):
         from .login import show_login_and_connect
 
         try:
-            new_comm = await show_login_and_connect()
+            new_comm, new_key = await show_login_and_connect()
         except asyncio.CancelledError:
             log.info("Login window closed without connecting; nothing left to do but quit.")
             self.quit()
@@ -155,6 +290,9 @@ class GUI(Module, IFitsHeaderBefore):
             self._logging_out = False
 
         self._comm = new_comm
+        if self._store is not None:
+            self._settings_key = new_key
+            self.settings = self._load_settings(new_key)
         try:
             await self.startup()
         except Exception as e:

pyobs_gui-2.6.0/pyobs_gui/guisignals.py

@@ -0,0 +1,16 @@
+"""App-wide Qt signals for things that aren't tied to one widget.
+
+Widgets are created per connected module and don't know about the window or the GUI module that
+owns the settings, so settings changes are announced here instead of passing a reference around.
+"""
+
+from PySide6 import QtCore  # type: ignore
+
+
+class GuiSignals(QtCore.QObject):
+    # emitted by whoever applied new settings (e.g. new VFS roots), after they are in effect;
+    # widgets re-read what they derived from them
+    settings_changed = QtCore.Signal()
+
+
+gui_signals = GuiSignals()

pyobs_gui-2.6.0/pyobs_gui/livestream.py

@@ -0,0 +1,181 @@
+"""Incremental parsers for BaseVideo's live-view streams (/video.mjpg and /video.raw).
+
+Both are fed the raw bytes of an HTTP/1.0 response as they arrive on the socket and return the
+frames completed so far. Kept free of Qt so they can be tested without a socket.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+class StreamError(Exception):
+    """The server answered the stream request with something other than 200 OK."""
+
+    def __init__(self, status: int | None, body: bytes):
+        self.status = status
+        self.body = body
+        text = body.decode("utf-8", errors="replace").strip()
+        super().__init__(f"HTTP status {status}: {text}" if text else f"HTTP status {status}")
+
+
+@dataclass
+class RawFrame:
+    """One frame from the raw stream."""
+
+    meta: dict[str, Any]
+    data: NDArray[Any]
+
+
+class _HttpStreamParser:
+    """Strips and checks the HTTP response header, then hands the body to _parse()."""
+
+    def __init__(self) -> None:
+        self._buffer = b""
+        self._headers_received = False
+
+    def feed(self, data: bytes) -> list[Any]:
+        """Add received bytes and return all frames completed by them.
+
+        Raises:
+            StreamError: If the response status is not 200.
+        """
+        self._buffer += data
+
+        # the boundary string also appears in the Content-Type header, so the header must go first
+        if not self._headers_received:
+            pos = self._buffer.find(b"\r\n\r\n")
+            if pos == -1:
+                return []
+            header, self._buffer = self._buffer[:pos], self._buffer[pos + 4 :]
+            self._headers_received = True
+            status = self._status(header)
+            if status != 200:
+                raise StreamError(status, self._buffer)
+
+        return self._parse()
+
+    @staticmethod
+    def _status(header: bytes) -> int | None:
+        """Status code from the response's status line, None if it can't be parsed."""
+        parts = header.split(b"\r\n", 1)[0].split()
+        if len(parts) < 2 or not parts[0].startswith(b"HTTP/"):
+            return None
+        try:
+            return int(parts[1])
+        except ValueError:
+            return None
+
+    def _parse(self) -> list[Any]:
+        raise NotImplementedError
+
+
+class MjpegParser(_HttpStreamParser):
+    """Parser for /video.mjpg, returns the JPEG bytes of each frame.
+
+    A frame is only complete once the next boundary arrives, since the parts carry no length.
+    """
+
+    BOUNDARY = b"--jpgboundary\r\n"
+
+    def _parse(self) -> list[bytes]:
+        frames: list[bytes] = []
+        while True:
+            pos = self._buffer.find(self.BOUNDARY)
+            if pos == -1:
+                return frames
+            part, self._buffer = self._buffer[:pos], self._buffer[pos + len(self.BOUNDARY) :]
+
+            # skip part header; empty for the preamble before the first boundary
+            header_end = part.find(b"\r\n\r\n")
+            if header_end == -1:
+                continue
+            jpeg = part[header_end + 4 :]
+            if jpeg:
+                frames.append(jpeg)
+
+
+class RawParser(_HttpStreamParser):
+    """Parser for /video.raw, returns decoded frames.
+
+    Each part carries its size implicitly (DTYPE and NAXISn in the meta header), so the payload is
+    read by length and never searched for the boundary, which could appear in binary data.
+    """
+
+    BOUNDARY = b"--rawboundary\r\n"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._meta: dict[str, Any] | None = None
+        self._size = 0
+
+    def _parse(self) -> list[RawFrame]:
+        frames: list[RawFrame] = []
+        while True:
+            if self._meta is None:
+                # boundary plus part header
+                start = self._buffer.find(self.BOUNDARY)
+                if start == -1:
+                    return frames
+                end = self._buffer.find(b"\r\n\r\n", start)
+                if end == -1:
+                    return frames
+                headers = self._buffer[start + len(self.BOUNDARY) : end]
+                self._buffer = self._buffer[end + 4 :]
+                self._meta = self._parse_meta(headers)
+                self._size = self._frame_size(self._meta)
+
+            # payload
+            if len(self._buffer) < self._size:
+                return frames
+            payload, self._buffer = self._buffer[: self._size], self._buffer[self._size :]
+            frames.append(RawFrame(self._meta, self._decode(self._meta, payload)))
+            self._meta = None
+
+    @staticmethod
+    def _parse_meta(headers: bytes) -> dict[str, Any]:
+        for line in headers.split(b"\r\n"):
+            name, _, value = line.partition(b":")
+            if name.strip().lower() == b"x-pyobs-frame-meta":
+                meta = json.loads(value.strip())
+                if not isinstance(meta, dict):
+                    raise ValueError("Frame meta is not a JSON object.")
+                return meta
+        raise ValueError("Frame without meta header.")
+
+    @staticmethod
+    def _shape(meta: dict[str, Any]) -> tuple[int, ...]:
+        """Array shape, NAXISn first (numpy order), e.g. (height, width) or (height, width, colour)."""
+        naxis = int(meta.get("NAXIS", 2))
+        return tuple(int(meta[f"NAXIS{i}"]) for i in range(naxis, 0, -1))
+
+    @classmethod
+    def _frame_size(cls, meta: dict[str, Any]) -> int:
+        return int(np.prod(cls._shape(meta))) * np.dtype(meta["DTYPE"]).itemsize
+
+    @classmethod
+    def _decode(cls, meta: dict[str, Any], payload: bytes) -> NDArray[Any]:
+        return np.frombuffer(payload, dtype=np.dtype(meta["DTYPE"])).reshape(cls._shape(meta))
+
+
+def fit_factor(full_width: int, full_height: int, view_width: int, view_height: int) -> int:
+    """Largest integer downsampling factor that keeps the image at least as large as the view.
+
+    Args:
+        full_width: Width of the full frame in pixels.
+        full_height: Height of the full frame in pixels.
+        view_width: Width of the view in pixels.
+        view_height: Height of the view in pixels.
+
+    Returns:
+        Factor, at least 1.
+    """
+    if view_width < 1 or view_height < 1:
+        return 1
+    return max(1, min(full_width // view_width, full_height // view_height))
+
+
+__all__ = ["StreamError", "RawFrame", "MjpegParser", "RawParser", "fit_factor"]

{pyobs_gui-2.5.2 → pyobs_gui-2.6.0}/pyobs_gui/login.py

@@ -15,15 +15,22 @@ from typing import Any
 from pyobs.comm.xmpp import XmppComm
 
 from .gui import GUI
-from .loginwindow import LoginWindow
+from .loginwindow import ConnectionRequest, LoginWindow
 
 log = logging.getLogger(__name__)
 
 
-async def show_login_and_connect() -> XmppComm:
+def settings_key(request: ConnectionRequest) -> str:
+    """Key of the settings in the settings file: the saved account id, or for a connection that
+    wasn't saved the bare JID (so its settings persist too)."""
+    return request.account_id or "jid:" + request.jid.split("/")[0]
+
+
+async def show_login_and_connect() -> tuple[XmppComm, str]:
     """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.
+    returns a fresh XmppComm built from the result, together with the key of its settings (see
+    `settings_key`).
 
     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
@@ -40,13 +47,14 @@ async def show_login_and_connect() -> XmppComm:
         window.close()
 
     log.info("Connecting as %s...", request.jid)
-    return XmppComm(
+    comm = XmppComm(
         jid=request.jid,
         password=request.password,
         server=request.server,
         use_tls=request.use_tls,
         ignore_cert_errors=request.insecure_skip_tls,
     )
+    return comm, settings_key(request)
 
 
 async def login_and_build_gui(**gui_kwargs: Any) -> GUI:
@@ -57,8 +65,8 @@ async def login_and_build_gui(**gui_kwargs: Any) -> GUI:
         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)
+    comm, key = await show_login_and_connect()
+    return GUI(comm=comm, standalone=True, settings_key=key, **gui_kwargs)
 
 
-__all__ = ["login_and_build_gui", "show_login_and_connect"]
+__all__ = ["login_and_build_gui", "settings_key", "show_login_and_connect"]