pyobs-gui 2.0.0.dev19__tar.gz → 2.0.0.dev21__tar.gz

{pyobs_gui-2.0.0.dev19 → pyobs_gui-2.0.0.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-gui
-Version: 2.0.0.dev19
+Version: 2.0.0.dev21
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
@@ -11,7 +11,7 @@ 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.dev78
+Requires-Dist: pyobs-core<3,>=2.0.0.dev93
 Requires-Dist: pyside6>=6.10.1
 Requires-Dist: qasync<0.29,>=0.27.1
 Requires-Dist: qfitswidget>=0.13.1

pyobs_gui-2.0.0.dev21/README.md

@@ -0,0 +1,28 @@
+pyobs-gui
+=========
+
+This is a [pyobs](https://www.pyobs.org) GUI for operating the whole system: one page per
+connected module (camera, telescope, roof, focuser, ...), plus Shell/Events/Status tool pages.
+
+
+Install *pyobs-gui*
+---------------------
+Clone the repository:
+
+    git clone https://github.com/pyobs/pyobs-gui.git
+    cd pyobs-gui
+
+Install it with [uv](https://docs.astral.sh/uv/):
+
+    uv sync
+
+
+Running
+-------
+Two ways to start it:
+
+- `uv run pyobs-gui` — standalone, interactive login. No YAML config needed; it prompts for XMPP
+  credentials (with an optional "store password") and connects directly.
+- `uv run pyobs <config.yaml>` — the standard `pyobs` CLI, driven by a config file whose top-level
+  class is `pyobs_gui.GUI` (see `docs/source/index.rst` for a full example, including how to wire
+  in a custom widget for a module).

pyobs_gui-2.0.0.dev21/docs/source/index.rst

@@ -0,0 +1,140 @@
+pyobs-gui
+#########
+
+This is a `pyobs <https://www.pyobs.org>`_ (`documentation <https://docs.pyobs.org>`_) module providing a GUI
+for operating the whole system.
+
+
+Example configuration
+**********************
+
+This is an example configuration for a GUI that defines one custom widget for the ``guiding`` module::
+
+    class: pyobs_gui.GUI
+
+    widgets:
+      - module: guiding
+        overwrite: True
+        widget:
+          class: mypackage.GuidingWidget
+
+    comm:
+      jid: test@example.com
+      password: ***
+
+    timezone: Europe/Berlin
+    location:
+      longitude: 9.944333
+      latitude: 51.560583
+      elevation: 201.
+
+    vfs:
+      class: pyobs.vfs.VirtualFileSystem
+      roots:
+        cache:
+          class: pyobs.vfs.HttpFile
+          download: http://localhost:37075/
+        webcam:
+          class: pyobs.vfs.HttpFile
+          download: http://localhost:37077/
+
+
+Available classes
+******************
+
+There is one single class for the GUI.
+
+GUI
+===
+.. autoclass:: pyobs_gui.GUI
+   :members:
+   :show-inheritance:
+
+
+Widgets
+*******
+
+The GUI shows one page per connected module, picking a widget by the module's interfaces
+(``DEFAULT_WIDGETS`` in ``mainwindow.py``), plus three always-present "Tools" pages. No screenshots
+yet — this section was written from source, not from a running GUI; add screenshots as a follow-up.
+
+Shell
+=====
+Always present. A command console: type shell-like commands against any connected module, with
+tab-completion driven by the module's own docstrings, and a per-module command history.
+
+Events
+======
+Always present. Live feed of events broadcast by connected modules, and lets you send one back.
+
+Status
+======
+Always present. Per-module connection/presence indicator plus a live, expandable tree of each
+connected module's published state.
+
+Camera — drives ``ICamera``
+============================
+Expose/abort control: binning, gain, image format/type, exposure time, full-frame vs. windowed
+readout, and (if the module supports it) data sequences.
+
+Telescope — drives ``ITelescope``
+====================================
+Init/park/stop and move-to-target, offsets in both RA/Dec and Alt/Az, Simbad and JPL Horizons
+target lookup, and tracking of orbital elements or solar-system bodies.
+
+Roof — drives ``IRoof``
+==========================
+Open/close/stop the roof, with live motion and pointing state.
+
+Focuser — drives ``IFocuser``
+================================
+Set an absolute focus value, apply/reset a focus offset.
+
+Auto Focus — drives ``IAutoFocus``
+=====================================
+Run or abort an autofocus sequence.
+
+Acquisition — drives ``IAcquisition``
+========================================
+Acquire a target, abort an in-progress acquisition.
+
+Auto Guiding — drives ``IAutoGuiding``
+=========================================
+Start/stop guiding and set the guide-exposure time.
+
+Weather — drives ``IWeather``
+================================
+Live sensor values plus a history plot.
+
+Video — drives ``IVideo``
+============================
+Live view (MJPEG/raw stream), grab a still, adjust exposure time/gain/image type.
+
+Spectrograph — drives ``ISpectrograph``
+==========================================
+Grab a spectrum, abort an in-progress exposure.
+
+Filter wheel — drives ``IFilters``
+=====================================
+Set the active filter.
+
+
+Keyboard shortcuts
+*******************
+
+Global, not per-widget — bound with the ``Ctrl``/``Ctrl+Alt`` modifier specifically so no
+text/numeric-entry widget can mistake one for ordinary input.
+
+===============  ==========================================================
+Shortcut          Action
+===============  ==========================================================
+``Ctrl+1``        Switch to Shell (fixed)
+``Ctrl+2``        Switch to Events (fixed)
+``Ctrl+3``        Switch to Status (fixed)
+``Ctrl+4``..``Ctrl+9``, ``Ctrl+0``
+                  Switch to whichever module page is bound to that slot
+                  (no-op if unbound or that module isn't connected)
+``Ctrl+Alt+4``..``Ctrl+Alt+9``, ``Ctrl+Alt+0``
+                  Bind the currently selected page to that slot, overwriting
+                  any previous binding
+===============  ==========================================================

{pyobs_gui-2.0.0.dev19 → pyobs_gui-2.0.0.dev21}/pyobs_gui/base.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 from typing import TYPE_CHECKING, Any, Callable, Type, TypeVar, overload
 
@@ -44,6 +45,13 @@ async def show_remote_error(parent: QtWidgets.QWidget, exception: Exception) ->
         await QAsyncMessageBox.warning(parent, "Error", str(exception))
 
 
+async def cancel_and_drain(task: asyncio.Task[Any]) -> None:
+    """Cancel a task and await its unwind, swallowing the resulting CancelledError."""
+    task.cancel()
+    with contextlib.suppress(asyncio.CancelledError):
+        await task
+
+
 class BaseWindow:
     def __init__(self) -> None:
         """Base class for MainWindow and all widgets."""
@@ -169,6 +177,14 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         # has it been initialized?
         self._initialized = False
 
+        # memoized one-shot init task -- two rapid show/hide/show cycles must not run _init()
+        # twice concurrently (see _showEvent)
+        self._init_task: asyncio.Task[Any] | None = None
+
+        # keys of _init_once() sub-steps that already completed, so a retried _init() (see
+        # _showEvent) skips steps that already ran instead of re-subscribing to comm state
+        self._init_steps_done: set[str] = set()
+
         # methods this GUI is permitted to invoke on self.module; None until fetched or if the
         # fetch failed, meaning "treat everything as permitted"
         self._permitted_methods: set[str] | None = None
@@ -251,6 +267,15 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         in Comm._event_handlers forever, keeping this widget alive and still reacting to
         events for as long as the app runs.
         """
+        # cancel a still-in-flight one-time _init() first: comm's own disconnect-triggered
+        # subscription cleanup (Comm._client_disconnected) runs before this method is called,
+        # so a subscribe_state() call inside _init_task that resolves afterwards would leak a
+        # subscription bound to this now-discarded widget -- the same stale-callback crash
+        # class this method otherwise guards against
+        if self._init_task is not None:
+            await cancel_and_drain(self._init_task)
+            self._init_task = None
+
         for event_class, handler in self._registered_event_handlers:
             await self.comm.unregister_event(event_class, handler)
         self._registered_event_handlers.clear()
@@ -263,14 +288,44 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         asyncio.create_task(self._showEvent(event))
 
     async def _showEvent(self, event: QtGui.QShowEvent) -> None:
-        if self._initialized is False and hasattr(self, "_init"):
-            await self._init()
-            self._initialized = True
+        if self._initialized is False:
+            if self._init_task is None:
+                self._init_task = asyncio.create_task(self._run_init())
+            try:
+                await self._init_task
+            except Exception:
+                # transient init failure (e.g. a comm RPC hiccup): log, and allow a retry on
+                # the next show instead of leaving the widget permanently marked initialized
+                log.exception("Init of %s failed; will retry on next show.", type(self).__name__)
+                self._init_task = None
 
         if self._update_func:
             # start update task
             self._update_task = asyncio.create_task(self._update_loop())
 
+    async def _run_init(self) -> None:
+        await self._init()
+        self._initialized = True
+
+    async def _init(self) -> None:
+        """Default no-op init. Widgets with one-time subscription/state setup override this;
+        _showEvent memoizes the call so it runs exactly once per widget lifetime."""
+
+    async def _init_once(self, key: str, coro_func: Callable[..., Coroutine[Any, Any, None]], *args: Any) -> None:
+        """Run one sub-step of _init() at most once across retries.
+
+        _showEvent retries the whole _init() after a partial failure (e.g. one of several
+        gathered comm.subscribe_state() calls raising while its siblings already subscribed).
+        comm.subscribe_state() unconditionally appends to comm's subscription list with no
+        deduplication, so a sub-step that already succeeded must not run again on retry --
+        override _init() and wrap each independent, subscribing sub-step in this instead of
+        calling it directly.
+        """
+        if key in self._init_steps_done:
+            return
+        await coro_func(*args)
+        self._init_steps_done.add(key)
+
     def hideEvent(self, event: QtGui.QHideEvent) -> None:
         # run in loop
         asyncio.create_task(self._hide_event(event))

{pyobs_gui-2.0.0.dev19 → pyobs_gui-2.0.0.dev21}/pyobs_gui/camerawidget.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from typing import Any
 from PySide6 import QtWidgets, QtCore  # type: ignore
@@ -38,6 +39,13 @@ from .qt.camerawidget_ui import Ui_CameraWidget
 log = logging.getLogger(__name__)
 
 
+# how long to wait for a module's first state value when initializing each control. The comm
+# default is 10 s per interface, which would let a slow-publishing camera hold the page blank
+# for ~70 s in the worst case; with this shorter timeout the control just keeps its default
+# value and the subscription callback corrects it as soon as state arrives.
+_WAIT_FOR_STATE_TIMEOUT = 2.0
+
+
 class CameraWidget(BaseWidget, Ui_CameraWidget):
     signal_update_gui = QtCore.Signal()
     signal_new_image = QtCore.Signal(NewImageEvent, str)
@@ -108,6 +116,26 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             await self.add_to_sidebar(self.create_widget(TemperaturesWidget, module=self.module))
 
     async def _init(self) -> None:
+        # every interface is initialized independently (caps -> state -> subscribe, in that
+        # order per interface), so run them concurrently instead of serially: a slow-publishing
+        # camera used to hold the page blank for up to ~70 s (7 interfaces x the 10 s default
+        # wait_for_state timeout); now each interface waits at most _WAIT_FOR_STATE_TIMEOUT and
+        # the others fill in regardless
+        await asyncio.gather(
+            self._init_once("window", self._init_window),
+            self._init_once("binning", self._init_binning),
+            self._init_once("gain", self._init_gain),
+            self._init_once("image_format", self._init_image_format),
+            self._init_once("image_type", self._init_image_type),
+            self._init_once("exposure", self._init_exposure),
+            self._init_once("exposure_time", self._init_exposure_time),
+            self._init_once("data_sequence", self._init_data_sequence),
+        )
+
+        # update GUI
+        self.signal_update_gui.emit()
+
+    async def _init_window(self) -> None:
         # window
         window_caps = await self.comm.get_capabilities(self.module, IWindow)
         if window_caps is not None:
@@ -117,7 +145,7 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             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:
-                state = await proxy.wait_for_state(IWindow)
+                state = await proxy.wait_for_state(IWindow, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 if state is not None:
                     self.spinWindowLeft.setValue(state.x)
                     self.spinWindowTop.setValue(state.y)
@@ -129,6 +157,7 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
                     self.spinWindowWidth.setValue(window_caps.full_frame_width)
                     self.spinWindowHeight.setValue(window_caps.full_frame_height)
 
+    async def _init_binning(self) -> None:
         # binning
         binning_caps = await self.comm.get_capabilities(self.module, IBinning)
         if binning_caps is not None:
@@ -137,20 +166,22 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             self.comboBinning.addItems(binnings)
         async with self.comm.safe_proxy(self.module, IBinning) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IBinning)
+                state = await proxy.wait_for_state(IBinning, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 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)
 
+    async def _init_gain(self) -> None:
         # gain
         async with self.comm.safe_proxy(self.module, IGain) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IGain)
+                state = await proxy.wait_for_state(IGain, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 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)
 
+    async def _init_image_format(self) -> None:
         # image format
         image_format_caps = await self.comm.get_capabilities(self.module, IImageFormat)
         if image_format_caps is not None:
@@ -159,44 +190,45 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             self.comboImageFormat.addItems([f.name for f in image_formats])
         async with self.comm.safe_proxy(self.module, IImageFormat) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IImageFormat)
+                state = await proxy.wait_for_state(IImageFormat, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 if state is not None:
                     self.comboImageFormat.setCurrentText(state.image_format.name)
         await self.comm.subscribe_state(self.module, IImageFormat, self._update_image_format)
 
+    async def _init_image_type(self) -> None:
         # image type
         async with self.comm.safe_proxy(self.module, IImageType) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IImageType)
+                state = await proxy.wait_for_state(IImageType, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 if state is not None:
                     self.comboImageType.setCurrentText(state.image_type.name)
         await self.comm.subscribe_state(self.module, IImageType, self._update_image_type)
 
+    async def _init_exposure(self) -> None:
         # exposure (status, progress, time left)
         async with self.comm.safe_proxy(self.module, IExposure) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IExposure)
+                state = await proxy.wait_for_state(IExposure, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 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)
 
+    async def _init_exposure_time(self) -> None:
         # exposure time
         async with self.comm.safe_proxy(self.module, IExposureTime) as proxy:
             if proxy is not None:
-                state = await proxy.wait_for_state(IExposureTime)
+                state = await proxy.wait_for_state(IExposureTime, timeout=_WAIT_FOR_STATE_TIMEOUT)
                 if state is not None:
                     self.spinExpTime.setValue(state.exposure_time)
         await self.comm.subscribe_state(self.module, IExposureTime, self._update_exposure_time)
 
+    async def _init_data_sequence(self) -> None:
         # 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_binning(self, state: BinningState):
         self.comboBinning.setCurrentText(f"{state.x}x{state.y}")