pyobs-gui 2.0.0.dev1__py3-none-any.whl → 2.0.0.dev2__py3-none-any.whl

pyobs_gui/acquisitionwidget.py

@@ -0,0 +1,152 @@
+import logging
+import os
+from typing import Any
+
+import qasync  # type: ignore
+from PySide6 import QtCore, QtWidgets  # type: ignore
+
+os.environ["QT_API"] = "PySide6"
+from matplotlib import pyplot as plt
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.ticker import MaxNLocator
+
+from pyobs.interfaces import (
+    AcquisitionAttempt,
+    AcquisitionResult,
+    AcquisitionState,
+    IAcquisition,
+    IRunning,
+    OffsetFrame,
+)
+from pyobs.interfaces.IRunning import RunningState
+from .base import BaseWidget
+from .qt.acquisitionwidget_ui import Ui_AcquisitionWidget
+
+log = logging.getLogger(__name__)
+
+
+class AcquisitionWidget(BaseWidget, Ui_AcquisitionWidget):
+    signal_update_gui = QtCore.Signal()
+
+    def __init__(self, **kwargs: Any):
+        BaseWidget.__init__(self, **kwargs)
+        self.setupUi(self)  # type: ignore
+
+        # cached state
+        self._attempts: list[AcquisitionAttempt] = []
+        self._running = False
+        self._result: AcquisitionResult | None = None
+
+        # add plots: distance vs. attempt, and the 2D offset trajectory
+        self.figure, (self.ax, self.ax2) = plt.subplots(1, 2)
+        layout = QtWidgets.QVBoxLayout(self.framePlot)
+        self.canvas = FigureCanvas(self.figure)
+        layout.addWidget(self.canvas)
+        self.framePlot.setLayout(layout)
+
+        # connect signals
+        self.signal_update_gui.connect(self.update_gui)
+        self.buttonAcquire.clicked.connect(self._acquire)
+        self.buttonAbort.clicked.connect(self._abort)
+
+        # button colors
+        self.colorize_button(self.buttonAcquire, QtCore.Qt.GlobalColor.green)
+        self.colorize_button(self.buttonAbort, QtCore.Qt.GlobalColor.red)
+
+    async def _init(self) -> None:
+        await self.comm.subscribe_state(self.module, IRunning, self._on_running_state)
+        await self.comm.subscribe_state(self.module, IAcquisition, self._on_acquisition_state)
+
+        # permitted methods (ACLs)
+        await self._fetch_permitted_methods()
+
+    def _on_running_state(self, state: RunningState) -> None:
+        if state.running and not self._running:
+            # rising edge -> a new run started (possibly triggered elsewhere), clear the plot
+            self._attempts = []
+            self._result = None
+        self._running = state.running
+        self.signal_update_gui.emit()
+
+    def _on_acquisition_state(self, state: AcquisitionState) -> None:
+        self._attempts = state.attempts
+        self._result = state.result
+        self.signal_update_gui.emit()
+
+    def update_gui(self) -> None:
+        self.buttonAcquire.setEnabled(not self._running and self.permitted("acquire_target"))
+        self.buttonAbort.setEnabled(self._running and self.permitted("abort"))
+        self.labelStatus.setText("Acquiring..." if self._running else "Acquired." if self._result else "Idle")
+
+        if self._result:
+            self.labelResultRa.setText(f"{self._result.ra:.5f}")
+            self.labelResultDec.setText(f"{self._result.dec:.5f}")
+            self.labelResultAlt.setText(f"{self._result.alt:.3f}")
+            self.labelResultAz.setText(f"{self._result.az:.3f}")
+            if self._result.offset_frame is not None:
+                label = "RA/Dec offset:" if self._result.offset_frame == OffsetFrame.RA_DEC else "Alt/Az offset:"
+                self.labelOffsetType.setText(label)
+                self.labelResultOffset.setText(f"({self._result.offset_lon:+.5f}, {self._result.offset_lat:+.5f})")
+            else:
+                self.labelOffsetType.setText("Offset:")
+                self.labelResultOffset.setText("")
+        else:
+            self.labelResultRa.setText("")
+            self.labelResultDec.setText("")
+            self.labelResultAlt.setText("")
+            self.labelResultAz.setText("")
+            self.labelOffsetType.setText("Offset:")
+            self.labelResultOffset.setText("")
+
+        self.ax.clear()
+        if self._attempts:
+            self.ax.plot(
+                [a.attempt for a in self._attempts],
+                [a.distance for a in self._attempts],
+                marker="o",
+                color="tab:blue",
+            )
+        self.ax.set_xlabel("Attempt")
+        self.ax.set_ylabel("Distance to target [arcsec]")
+        self.ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+        self.ax.grid(linestyle=":", alpha=0.5)
+        self.ax.set_axisbelow(True)
+
+        self.ax2.clear()
+        offset_attempts = [a for a in self._attempts if a.offset_frame is not None]
+        points = [(a.offset_lon, a.offset_lat) for a in offset_attempts]
+        if offset_attempts and offset_attempts[0].offset_frame == OffsetFrame.RA_DEC:
+            xlabel, ylabel = "RA offset [deg]", "Dec offset [deg]"
+        elif offset_attempts and offset_attempts[0].offset_frame == OffsetFrame.ALT_AZ:
+            xlabel, ylabel = "Alt offset [deg]", "Az offset [deg]"
+        else:
+            xlabel, ylabel = "Offset 1 [deg]", "Offset 2 [deg]"
+        if points:
+            xs, ys = zip(*points, strict=True)
+            self.ax2.axhline(0, color="gray", linewidth=0.5)
+            self.ax2.axvline(0, color="gray", linewidth=0.5)
+            self.ax2.plot(xs, ys, marker="o", color="tab:orange")
+            self.ax2.plot(xs[0], ys[0], marker="s", color="tab:red", markersize=8, linestyle="", label="start")
+            self.ax2.plot(xs[-1], ys[-1], marker="*", color="tab:green", markersize=12, linestyle="", label="latest")
+            self.ax2.legend(fontsize="small")
+            self.ax2.set_aspect("equal", adjustable="datalim")
+        self.ax2.set_xlabel(xlabel)
+        self.ax2.set_ylabel(ylabel)
+        self.ax2.grid(linestyle=":", alpha=0.5)
+        self.ax2.set_axisbelow(True)
+
+        self.figure.tight_layout()
+        self.canvas.draw()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _acquire(self) -> None:
+        async with self.comm.proxy(self.module, IAcquisition) as proxy:
+            await proxy.acquire_target()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _abort(self) -> None:
+        async with self.comm.proxy(self.module, IAcquisition) as proxy:
+            await proxy.abort()
+
+
+__all__ = ["AcquisitionWidget"]

pyobs_gui/autofocuswidget.py

@@ -0,0 +1,109 @@
+import logging
+import os
+from typing import Any
+
+import qasync  # type: ignore
+from PySide6 import QtCore, QtWidgets  # type: ignore
+
+os.environ["QT_API"] = "PySide6"
+from matplotlib import pyplot as plt
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+
+from pyobs.events import Event, FocusFoundEvent
+from pyobs.interfaces import AutoFocusPoint, AutoFocusState, IAutoFocus, IRunning, RunningState
+from .base import BaseWidget
+from .qt.autofocuswidget_ui import Ui_AutoFocusWidget
+
+log = logging.getLogger(__name__)
+
+
+class AutoFocusWidget(BaseWidget, Ui_AutoFocusWidget):
+    signal_update_gui = QtCore.Signal()
+
+    def __init__(self, **kwargs: Any):
+        BaseWidget.__init__(self, **kwargs)
+        self.setupUi(self)  # type: ignore
+
+        # cached state
+        self._points: list[AutoFocusPoint] = []
+        self._running = False
+        self._last_result: tuple[float, float] | None = None
+
+        # add plot
+        self.figure, self.ax = plt.subplots()
+        layout = QtWidgets.QVBoxLayout(self.framePlot)
+        self.canvas = FigureCanvas(self.figure)
+        layout.addWidget(self.canvas)
+        self.framePlot.setLayout(layout)
+
+        # connect signals
+        self.signal_update_gui.connect(self.update_gui)
+        self.buttonRunAutoFocus.clicked.connect(self._run_auto_focus)
+        self.buttonAbort.clicked.connect(self._abort)
+
+        # button colors
+        self.colorize_button(self.buttonRunAutoFocus, QtCore.Qt.GlobalColor.green)
+        self.colorize_button(self.buttonAbort, QtCore.Qt.GlobalColor.red)
+
+    async def _init(self) -> None:
+        await self.comm.subscribe_state(self.module, IRunning, self._on_running_state)
+        await self.comm.subscribe_state(self.module, IAutoFocus, self._on_autofocus_state)
+        await self.register_event(FocusFoundEvent, self._on_focus_found)
+
+        # permitted methods (ACLs)
+        await self._fetch_permitted_methods()
+
+    def _on_running_state(self, state: RunningState) -> None:
+        if state.running and not self._running:
+            # rising edge -> a new run started (possibly triggered elsewhere), clear the plot
+            self._points = []
+            self._last_result = None
+        self._running = state.running
+        self.signal_update_gui.emit()
+
+    def _on_autofocus_state(self, state: AutoFocusState) -> None:
+        self._points = state.points
+        self.signal_update_gui.emit()
+
+    async def _on_focus_found(self, event: Event, sender: str) -> bool:
+        if sender != self.module or not isinstance(event, FocusFoundEvent):
+            return False
+        self._last_result = (event.focus, event.error or 0.0)
+        self.signal_update_gui.emit()
+        return True
+
+    def update_gui(self) -> None:
+        self.buttonRunAutoFocus.setEnabled(not self._running and self.permitted("auto_focus"))
+        self.buttonAbort.setEnabled(self._running and self.permitted("abort"))
+        self.labelStatus.setText(
+            "Running..."
+            if self._running
+            else f"Focus: {self._last_result[0]:.3f} ± {self._last_result[1]:.3f} mm"
+            if self._last_result
+            else "Idle"
+        )
+
+        self.ax.clear()
+        if self._points:
+            self.ax.scatter([p.focus for p in self._points], [p.value for p in self._points], color="tab:blue")
+        if self._last_result and not self._running:
+            self.ax.axvline(self._last_result[0], color="tab:green", linestyle="--", label="fitted focus")
+            self.ax.legend()
+        self.ax.set_xlabel("Focus [mm]")
+        self.ax.set_ylabel("Metric")
+        self.ax.grid(linestyle=":", alpha=0.5)
+        self.ax.set_axisbelow(True)
+        self.canvas.draw()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _run_auto_focus(self) -> None:
+        async with self.comm.proxy(self.module, IAutoFocus) as proxy:
+            await proxy.auto_focus(self.spinCount.value(), self.spinStep.value(), self.spinExposureTime.value())
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _abort(self) -> None:
+        async with self.comm.proxy(self.module, IAutoFocus) as proxy:
+            await proxy.abort()
+
+
+__all__ = ["AutoFocusWidget"]

pyobs_gui/autoguidingwidget.py

@@ -0,0 +1,150 @@
+import logging
+import math
+import os
+from collections import deque
+from typing import Any
+
+import qasync  # type: ignore
+from PySide6 import QtCore, QtWidgets  # type: ignore
+
+os.environ["QT_API"] = "PySide6"
+from matplotlib import pyplot as plt
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.ticker import MaxNLocator
+
+from pyobs.interfaces import GuidingState, IAutoGuiding, IExposureTime, IRunning, OffsetFrame
+from pyobs.interfaces.IExposureTime import ExposureTimeState
+from pyobs.interfaces.IRunning import RunningState
+from .base import BaseWidget
+from .qt.autoguidingwidget_ui import Ui_AutoGuidingWidget
+
+log = logging.getLogger(__name__)
+
+_HISTORY_LENGTH = 50
+
+
+class AutoGuidingWidget(BaseWidget, Ui_AutoGuidingWidget):
+    signal_update_gui = QtCore.Signal()
+
+    def __init__(self, **kwargs: Any):
+        BaseWidget.__init__(self, **kwargs)
+        self.setupUi(self)  # type: ignore
+
+        # cached state
+        self._running = False
+        self._loop_closed = False
+        self._exposure_time: float | None = None
+        self._offset_frame: OffsetFrame | None = None
+        self._offset: tuple[float, float] | None = None  # last (lon, lat), arcsec
+        self._offset_history: deque[tuple[float, float]] = deque(maxlen=_HISTORY_LENGTH)
+
+        # add plots: offset magnitude vs. sample, and the lon/lat scatter
+        self.figure, (self.ax, self.ax2) = plt.subplots(1, 2)
+        layout = QtWidgets.QVBoxLayout(self.framePlot)
+        self.canvas = FigureCanvas(self.figure)
+        layout.addWidget(self.canvas)
+        self.framePlot.setLayout(layout)
+
+        # connect signals
+        self.signal_update_gui.connect(self.update_gui)
+        self.buttonStart.clicked.connect(self._start)
+        self.buttonStop.clicked.connect(self._stop)
+        self.spinExposureTime.init_modified(self.labelExposureTime).committed.connect(self._set_exposure_time)
+
+        # button colors
+        self.colorize_button(self.buttonStart, QtCore.Qt.GlobalColor.green)
+        self.colorize_button(self.buttonStop, QtCore.Qt.GlobalColor.red)
+
+    async def _init(self) -> None:
+        await self.comm.subscribe_state(self.module, IRunning, self._on_running_state)
+        await self.comm.subscribe_state(self.module, IExposureTime, self._on_exptime_state)
+        await self.comm.subscribe_state(self.module, IAutoGuiding, self._on_guiding_state)
+
+        # permitted methods (ACLs)
+        await self._fetch_permitted_methods()
+
+    def _on_running_state(self, state: RunningState) -> None:
+        if state.running and not self._running:
+            # rising edge -> a new run started (possibly triggered elsewhere), clear the history
+            self._offset_history.clear()
+        self._running = state.running
+        self.signal_update_gui.emit()
+
+    def _on_exptime_state(self, state: ExposureTimeState) -> None:
+        # only follow live updates while the spin box isn't mid-edit, so a user's in-progress
+        # value isn't clobbered by a state update from elsewhere
+        was_synced = self._exposure_time is None or self.spinExposureTime.value() == self._exposure_time
+        self._exposure_time = state.exposure_time
+        self.labelExposureTime.setText(f"{state.exposure_time:.1f}")
+        if was_synced:
+            self.spinExposureTime.setValue(state.exposure_time)
+        self.signal_update_gui.emit()
+
+    def _on_guiding_state(self, state: GuidingState) -> None:
+        self._loop_closed = state.loop_closed
+        self._offset_frame = state.offset_frame
+        if state.offset_lon is not None and state.offset_lat is not None:
+            self._offset = (state.offset_lon * 3600, state.offset_lat * 3600)
+            self._offset_history.append(self._offset)
+        self.signal_update_gui.emit()
+
+    def update_gui(self) -> None:
+        self.buttonStart.setEnabled(not self._running and self.permitted("start"))
+        self.buttonStop.setEnabled(self._running and self.permitted("stop"))
+        self.spinExposureTime.setEnabled(self.permitted("set_exposure_time"))
+        self.labelLoopState.setText(
+            "Closed loop" if self._running and self._loop_closed else "Open loop" if self._running else "Stopped"
+        )
+        self.labelOffset.setText(f"({self._offset[0]:+.2f}, {self._offset[1]:+.2f}) arcsec" if self._offset else "")
+
+        self.ax.clear()
+        if self._offset_history:
+            magnitudes = [math.sqrt(lon**2 + lat**2) for lon, lat in self._offset_history]
+            self.ax.plot(range(1, len(magnitudes) + 1), magnitudes, marker="o", color="tab:blue")
+        self.ax.set_xlabel("Sample")
+        self.ax.set_ylabel("Offset magnitude [arcsec]")
+        self.ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+        self.ax.grid(linestyle=":", alpha=0.5)
+        self.ax.set_axisbelow(True)
+
+        self.ax2.clear()
+        if self._offset_frame == OffsetFrame.RA_DEC:
+            xlabel, ylabel = "RA offset [arcsec]", "Dec offset [arcsec]"
+        elif self._offset_frame == OffsetFrame.ALT_AZ:
+            xlabel, ylabel = "Alt offset [arcsec]", "Az offset [arcsec]"
+        else:
+            xlabel, ylabel = "Offset 1 [arcsec]", "Offset 2 [arcsec]"
+        if self._offset_history:
+            xs, ys = zip(*self._offset_history, strict=True)
+            self.ax2.axhline(0, color="gray", linewidth=0.5)
+            self.ax2.axvline(0, color="gray", linewidth=0.5)
+            self.ax2.plot(xs, ys, marker="o", linestyle="", color="tab:orange")
+            self.ax2.plot(xs[-1], ys[-1], marker="*", color="tab:green", markersize=12, linestyle="", label="latest")
+            self.ax2.legend(fontsize="small")
+            self.ax2.set_aspect("equal", adjustable="datalim")
+        self.ax2.set_xlabel(xlabel)
+        self.ax2.set_ylabel(ylabel)
+        self.ax2.grid(linestyle=":", alpha=0.5)
+        self.ax2.set_axisbelow(True)
+
+        self.figure.tight_layout()
+        self.canvas.draw()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _start(self) -> None:
+        async with self.comm.proxy(self.module, IAutoGuiding) as proxy:
+            await proxy.start()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _stop(self) -> None:
+        async with self.comm.proxy(self.module, IAutoGuiding) as proxy:
+            await proxy.stop()
+
+    @qasync.asyncSlot()  # type: ignore
+    async def _set_exposure_time(self) -> None:
+        value = self.spinExposureTime.value()
+        async with self.comm.proxy(self.module, IExposureTime) as proxy:
+            await proxy.set_exposure_time(value)
+
+
+__all__ = ["AutoGuidingWidget"]

pyobs_gui/base.py

@@ -5,6 +5,7 @@ import logging
 from typing import TYPE_CHECKING, Any, Callable, Type, TypeVar, overload
 
 import pyobs.utils.exceptions as exc
+from pyobs.interfaces import IModule
 from pyobs.object import create_object
 from pyobs.utils.enums import ModuleState
 from PySide6 import QtCore, QtGui, QtWidgets  # type: ignore
@@ -16,6 +17,8 @@ if TYPE_CHECKING:
 
     from astroplan import Observer
     from pyobs.comm import Comm
+    from pyobs.events import Event
+    from pyobs.interfaces import FitsHeaderEntry
     from pyobs.vfs import VirtualFileSystem
 
 log = logging.getLogger(__name__)
@@ -150,6 +153,16 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         # has it been initialized?
         self._initialized = False
 
+        # 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
+
+        # (event_class, handler) pairs registered via self.register_event(), so discard() can
+        # unregister them all -- comm.register_event() has no automatic per-client teardown like
+        # subscribe_state()/subscribe_presence() do, since a handler isn't inherently tied to one
+        # remote module, so whoever registers it is responsible for unregistering it
+        self._registered_event_handlers: list[tuple[type[Event], Callable[[Event, str], Any]]] = []
+
     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
         if self.extract_window_button:
             self.extract_window_button.move(self.width() - 20, 0)
@@ -203,6 +216,32 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         self.sidebar_widgets.append(widget)
         self.sidebar_layout.insertWidget(len(self.sidebar_widgets) - 1, widget)
 
+    async def register_event(self, event_class: type[Event], handler: Callable[[Event, str], Any]) -> None:
+        """Register an event handler through comm, tracked so discard() can unregister it later.
+
+        Widgets that are created/destroyed per connected client (see DEFAULT_WIDGETS in
+        mainwindow.py) must use this instead of calling self.comm.register_event() directly,
+        so their handler stops firing once the widget is discarded.
+        """
+        await self.comm.register_event(event_class, handler)
+        self._registered_event_handlers.append((event_class, handler))
+
+    async def discard(self) -> None:
+        """Tear down everything this widget registered with comm, and recursively discard
+        its sidebar widgets.
+
+        Must be called (e.g. from mainwindow._client_disconnected) whenever a widget is
+        removed from the UI -- otherwise a handler registered via register_event() lingers
+        in Comm._event_handlers forever, keeping this widget alive and still reacting to
+        events for as long as the app runs.
+        """
+        for event_class, handler in self._registered_event_handlers:
+            await self.comm.unregister_event(event_class, handler)
+        self._registered_event_handlers.clear()
+
+        for widget in self.sidebar_widgets:
+            await widget.discard()
+
     def showEvent(self, event: QtGui.QShowEvent) -> None:
         # run in loop
         asyncio.create_task(self._showEvent(event))
@@ -250,7 +289,7 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
                 # sleep a little
                 await asyncio.sleep(1)
 
-            except (exc.PyObsError, IndexError):
+            except (exc.PyobsError, IndexError):
                 # ignore these and sleep a little
                 await asyncio.sleep(1)
 
@@ -269,7 +308,7 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         # call method
         try:
             await method(*args, **kwargs)
-        except exc.PyObsError as e:
+        except exc.PyobsError as e:
             await self.show_error(e)
         except Exception as e:
             log.exception("An error occurred.")
@@ -278,7 +317,7 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
             # enable widgets
             self._enable_buttons.emit(disable, True)
 
-    async def show_error(self, exception: exc.PyObsError) -> None:
+    async def show_error(self, exception: exc.PyobsError) -> None:
         err = str(exception)
         title, message = err.split(":") if ":" in err else ("Error", err)
         await QAsyncMessageBox.warning(self, title, message)
@@ -287,7 +326,23 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         for w in widgets:
             w.setEnabled(enable)
 
-    def get_fits_headers(self, namespaces: list[str] | None = None, **kwargs: Any) -> dict[str, tuple[Any, str]]:
+    async def _fetch_permitted_methods(self) -> None:
+        # leaves _permitted_methods at None on failure, so permitted() falls back to "everything
+        # allowed" - an actual denial still surfaces via ForbiddenError in _background_task
+        if not hasattr(IModule, "get_permitted_methods"):
+            # pyobs-core older than the ACL feature (still within our supported version range)
+            return
+        try:
+            async with self.comm.proxy(self.module, IModule) as proxy:
+                self._permitted_methods = set(await proxy.get_permitted_methods())
+        except exc.PyobsError:
+            self._permitted_methods = None
+
+    def permitted(self, method: str) -> bool:
+        """Returns whether this GUI is permitted to invoke the given method on self.module."""
+        return self._permitted_methods is None or method in self._permitted_methods
+
+    def get_fits_headers(self, namespaces: list[str] | None = None, **kwargs: Any) -> dict[str, FitsHeaderEntry]:
         """Returns FITS header for the current status of this module.
 
         Args:

pyobs_gui/camerawidget.py

@@ -25,6 +25,8 @@ from pyobs.interfaces import (
     GainState,
     IExposure,
     ExposureState,
+    IDataSequence,
+    DataSequenceState,
 )
 from pyobs.utils.enums import ImageType, ImageFormat, ExposureStatus
 from pyobs.vfs import VirtualFileSystem
@@ -153,6 +155,9 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             if proxy is not None:
                 await self.comm.subscribe_state(self.module, IExposureTime, self._update_exposure_time)
 
+        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()
 
@@ -185,6 +190,10 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         self.spinExpTime.setValue(state.exposure_time)
         self.update_gui()
 
+    def _update_sequence(self, state: DataSequenceState):
+        self.exposures_left = state.count_left
+        self.update_gui()
+
     @qasync.asyncSlot()
     async def _window_changed(self):
         print("ok")
@@ -238,19 +247,21 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
 
     @qasync.asyncSlot()  # type: ignore
     async def expose(self) -> None:
-        # 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
+        async with self.comm.safe_proxy(self.module, IDataSequence) as proxy:
+            if proxy is not None:
+                await proxy.grab_sequence(count, broadcast)
+                return
 
-        # do exposure(s)
+        # fall back to a client-side loop for modules that don't support IDataSequence
+        self.exposures_left = count
         while self.exposures_left > 0:
-            # expose
-            broadcast = self.checkBroadcast.isChecked()
             await self.datadisplay.grab_data(broadcast)
-
-            # decrement number of exposures left
             self.exposures_left -= 1
-
-            # signal GUI update
             self.signal_update_gui.emit()
 
     @qasync.asyncSlot()  # type: ignore
@@ -262,7 +273,12 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
 
         # got exposures left?
         if self.exposures_left > 1:
-            # abort sequence
+            # soft-stop the sequence server-side (current grab finishes normally), if
+            # supported; otherwise just stop the client-side loop after the current grab
+            async with self.comm.safe_proxy(self.module, IDataSequence) as proxy:
+                if proxy is not None:
+                    await proxy.abort_sequence()
+                    return
             self.exposures_left = 0
         else:
             async with self.comm.safe_proxy(self.module, IAbortable) as proxy:

pyobs_gui/compassmovewidget.py

@@ -42,20 +42,27 @@ class CompassMoveWidget(BaseWidget, Ui_CompassMoveWidget):
         has_offsets_radec = await self.comm.has_proxy(self.module, IOffsetsRaDec)
         if has_offsets_altaz and has_pointing_altaz:
             async with self.comm.proxy(self.module, IPointingAltAz) as p:
-                alt, az = await p.get_altaz()  # type: ignore[attr-defined]
+                altaz_state = await p.wait_for_state(IPointingAltAz, timeout=5.0)
+            if altaz_state is None:
+                return
             altaz = SkyCoord(
-                alt=alt * u.degree,  # type: ignore[attr-defined]
-                az=az * u.degree,  # type: ignore[attr-defined]
+                alt=altaz_state.alt * u.degree,
+                az=altaz_state.az * u.degree,
                 obstime=Time.now(),
                 location=self.observer.location,
                 frame="altaz",
             )
             async with self.comm.proxy(self.module, IOffsetsAltAz) as p:
-                off_alt, off_az = await p.get_offsets_altaz()  # type: ignore[attr-defined]
-            off_ra, off_dec = offset_altaz_to_radec(altaz, off_alt, off_az)
+                offset_state = await p.wait_for_state(IOffsetsAltAz, timeout=5.0)
+            if offset_state is None:
+                return
+            off_ra, off_dec = offset_altaz_to_radec(altaz, offset_state.alt, offset_state.az)
         elif has_offsets_radec:
             async with self.comm.proxy(self.module, IOffsetsRaDec) as p:
-                off_ra, off_dec = await p.get_offsets_radec()  # type: ignore[attr-defined]
+                offset_state = await p.wait_for_state(IOffsetsRaDec, timeout=5.0)
+            if offset_state is None:
+                return
+            off_ra, off_dec = offset_state.ra, offset_state.dec
         else:
             return
 

pyobs_gui/datadisplaywidget.py

@@ -77,8 +77,8 @@ class DataDisplayWidget(BaseWidget, Ui_DataDisplayWidget):
             raise ValueError("Unknown type")
 
         # subscribe to events
-        await self.comm.register_event(NewImageEvent, self._on_new_data)
-        await self.comm.register_event(NewSpectrumEvent, self._on_new_data)
+        await self.register_event(NewImageEvent, self._on_new_data)
+        await self.register_event(NewSpectrumEvent, self._on_new_data)
 
     async def grab_data(self, broadcast: bool) -> None:
         """Grab data."""

pyobs_gui/filterwidget.py

@@ -38,6 +38,9 @@ class FilterWidget(BaseWidget, Ui_FilterWidget):
         await self.comm.subscribe_state(self.module, IFilters, self._on_filter_state)
         await self.comm.subscribe_state(self.module, IMotion, self._on_motion_state)
 
+        # permitted methods (ACLs)
+        await self._fetch_permitted_methods()
+
     def _on_filter_state(self, state: FilterState) -> None:
         self._filter = state.filter
         self.signal_update_gui.emit()
@@ -56,7 +59,7 @@ class FilterWidget(BaseWidget, Ui_FilterWidget):
             MotionStatus.IDLE,
             MotionStatus.POSITIONED,
         ]
-        self.buttonSetFilter.setEnabled(initialized)
+        self.buttonSetFilter.setEnabled(initialized and self.permitted("set_filter"))
 
     @qasync.asyncSlot()  # type: ignore
     async def set_filter(self) -> None: