pyobs-gui 2.0.0.dev16__tar.gz → 2.0.0.dev18__tar.gz

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-gui
-Version: 2.0.0.dev16
+Version: 2.0.0.dev18
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/acquisitionwidget.py

@@ -2,7 +2,6 @@ import logging
 import os
 from typing import Any
 
-import qasync  # type: ignore
 from PySide6 import QtCore, QtWidgets  # type: ignore
 
 os.environ["QT_API"] = "PySide6"
@@ -147,13 +146,17 @@ class AcquisitionWidget(BaseWidget, Ui_AcquisitionWidget):
 
         self.canvas.draw()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _acquire(self) -> None:
+    def _acquire(self) -> None:
+        self.run_background(self._acquire_target)
+
+    async def _acquire_target(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:
+    def _abort(self) -> None:
+        self.run_background(self._abort_acquisition)
+
+    async def _abort_acquisition(self) -> None:
         async with self.comm.proxy(self.module, IAcquisition) as proxy:
             await proxy.abort()
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/autofocuswidget.py

@@ -2,7 +2,6 @@ import logging
 import os
 from typing import Any
 
-import qasync  # type: ignore
 from PySide6 import QtCore, QtWidgets  # type: ignore
 
 os.environ["QT_API"] = "PySide6"
@@ -78,9 +77,7 @@ class AutoFocusWidget(BaseWidget, Ui_AutoFocusWidget):
         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"
+            else f"Focus: {self._last_result[0]:.3f} ± {self._last_result[1]:.3f} mm" if self._last_result else "Idle"
         )
 
         self.ax.clear()
@@ -95,13 +92,19 @@ class AutoFocusWidget(BaseWidget, Ui_AutoFocusWidget):
         self.ax.set_axisbelow(True)
         self.canvas.draw()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _run_auto_focus(self) -> None:
+    def _run_auto_focus(self) -> None:
+        self.run_background(
+            self._auto_focus, self.spinCount.value(), self.spinStep.value(), self.spinExposureTime.value()
+        )
+
+    async def _auto_focus(self, count: int, step: float, exposure_time: float) -> None:
         async with self.comm.proxy(self.module, IAutoFocus) as proxy:
-            await proxy.auto_focus(self.spinCount.value(), self.spinStep.value(), self.spinExposureTime.value())
+            await proxy.auto_focus(count, step, exposure_time)
+
+    def _abort(self) -> None:
+        self.run_background(self._abort_focus)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _abort(self) -> None:
+    async def _abort_focus(self) -> None:
         async with self.comm.proxy(self.module, IAutoFocus) as proxy:
             await proxy.abort()
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/autoguidingwidget.py

@@ -4,7 +4,6 @@ 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"
@@ -130,19 +129,25 @@ class AutoGuidingWidget(BaseWidget, Ui_AutoGuidingWidget):
         self.figure.tight_layout()
         self.canvas.draw()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _start(self) -> None:
+    def _start(self) -> None:
+        self.run_background(self._start_guiding)
+
+    async def _start_guiding(self) -> None:
         async with self.comm.proxy(self.module, IAutoGuiding) as proxy:
             await proxy.start()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _stop(self) -> None:
+    def _stop(self) -> None:
+        self.run_background(self._stop_guiding)
+
+    async def _stop_guiding(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:
+    def _set_exposure_time(self) -> None:
         value = self.spinExposureTime.value()
+        self.run_background(self._set_exposure_time_async, value)
+
+    async def _set_exposure_time_async(self, value: float) -> None:
         async with self.comm.proxy(self.module, IExposureTime) as proxy:
             await proxy.set_exposure_time(value)
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/base.py

@@ -26,6 +26,24 @@ log = logging.getLogger(__name__)
 WidgetClass = TypeVar("WidgetClass", bound="BaseWidget")
 
 
+async def show_remote_error(parent: QtWidgets.QWidget, exception: Exception) -> None:
+    """Show a remote-call failure to the user.
+
+    Single shared path for surfacing exceptions from remote method calls: `PyobsError`
+    (domain errors like `MoveError`, and transport errors like `RemoteError`) shows a warning
+    box titled with the exception class; any other `Exception` is logged and shown as a plain
+    warning. Used by `BaseWidget._background_task()` (everything routed through
+    `run_background()`) and by non-`BaseWidget` callers like `StatusItem`.
+    """
+    if isinstance(exception, exc.PyobsError):
+        # PyobsError.__str__ already prefixes the class name ("<MoveError> msg"); the class name
+        # is the dialog title, so show only the message itself
+        await QAsyncMessageBox.warning(parent, type(exception).__name__, exception.message or str(exception))
+    else:
+        log.exception("An error occurred.")
+        await QAsyncMessageBox.warning(parent, "Error", str(exception))
+
+
 class BaseWindow:
     def __init__(self) -> None:
         """Base class for MainWindow and all widgets."""
@@ -120,7 +138,6 @@ class BaseWindow:
 
 
 class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
-    _show_error = QtCore.Signal(str)
     _enable_buttons = QtCore.Signal(list, bool)
 
     def __init__(
@@ -134,7 +151,6 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         QtWidgets.QWidget.__init__(self)
 
         # signals
-        self._show_error.connect(self.show_error)
         self._enable_buttons.connect(self.enable_buttons)
 
         # update
@@ -271,6 +287,7 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
                 self._update_task = None
 
     async def _update_loop(self) -> None:
+        consecutive_failures = 0
         while True:
             try:
                 # get module state
@@ -288,9 +305,14 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
 
                 # sleep a little
                 await asyncio.sleep(1)
-
-            except (exc.PyobsError, IndexError):
-                # ignore these and sleep a little
+                consecutive_failures = 0
+
+            except (exc.PyobsError, IndexError) as e:
+                # background polling failures must not pop a dialog per failed poll -- log the
+                # first failure, then every 60th (~once a minute at the 1s poll interval)
+                consecutive_failures += 1
+                if consecutive_failures % 60 == 1:
+                    log.warning("Update of %s failed: %s", self.module, e)
                 await asyncio.sleep(1)
 
     def run_background(self, method: Callable[..., Coroutine[Any, Any, None]], *args: Any, **kwargs: Any) -> None:
@@ -308,20 +330,12 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
         # call method
         try:
             await method(*args, **kwargs)
-        except exc.PyobsError as e:
-            await self.show_error(e)
         except Exception as e:
-            log.exception("An error occurred.")
-            await QAsyncMessageBox.warning(self, "Error", str(e))
+            await show_remote_error(self, e)
         finally:
             # enable widgets
             self._enable_buttons.emit(disable, True)
 
-    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)
-
     def enable_buttons(self, widgets: list[QtWidgets.QWidget], enable: bool) -> None:
         for w in widgets:
             w.setEnabled(enable)

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/camerawidget.py

@@ -1,6 +1,5 @@
 import logging
 from typing import Any
-import qasync  # type: ignore
 from PySide6 import QtWidgets, QtCore  # type: ignore
 from astroplan import Observer
 
@@ -225,8 +224,10 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         self.exposures_left = state.count_left
         self.update_gui()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def set_full_frame(self) -> None:
+    def set_full_frame(self) -> None:
+        self.run_background(self._do_set_full_frame)
+
+    async def _do_set_full_frame(self) -> None:
         caps = await self.comm.get_capabilities(self.module, IWindow)
         if caps is not None:
             # get binning
@@ -268,18 +269,15 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
         else:
             self.spinExpTime.setEnabled(True)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def expose(self) -> None:
+    def expose(self) -> None:
+        self.run_background(self._do_expose)
+
+    async def _do_expose(self) -> None:
         # set binning
         async with self.comm.safe_proxy(self.module, IBinning) as proxy:
             if proxy is not None:
                 binning = int(self.comboBinning.currentText()[0])
-                try:
-                    await proxy.set_binning(binning, binning)
-                except Exception:
-                    log.exception("bla")
-                    QtWidgets.QMessageBox.information(self, "Error", "Could not set binning.")
-                    return
+                await proxy.set_binning(binning, binning)
             else:
                 binning = 1
 
@@ -288,11 +286,7 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             if proxy is not None:
                 left, top = self.spinWindowLeft.value(), self.spinWindowTop.value()
                 width, height = self.spinWindowWidth.value(), self.spinWindowHeight.value()
-                try:
-                    await proxy.set_window(left, top, width * binning, height * binning)
-                except Exception:
-                    QtWidgets.QMessageBox.information(self, "Error", "Could not set window.")
-                    return
+                await proxy.set_window(left, top, width * binning, height * binning)
 
         # set image format
         async with self.comm.safe_proxy(self.module, IImageFormat) as proxy:
@@ -348,13 +342,15 @@ class CameraWidget(BaseWidget, Ui_CameraWidget):
             self.exposures_left -= 1
             self.signal_update_gui.emit()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def abort(self) -> None:
+    def abort(self) -> None:
         """Abort exposure."""
         # do we have a running exposure?
         if self.exposures_left == 0:
             return
 
+        self.run_background(self._do_abort)
+
+    async def _do_abort(self) -> None:
         # got exposures left?
         if self.exposures_left > 1:
             # soft-stop the sequence server-side (current grab finishes normally), if

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/coolingwidget.py

@@ -1,4 +1,3 @@
-import qasync
 import logging
 from typing import Any
 from PySide6 import QtCore  # type: ignore
@@ -47,9 +46,11 @@ class CoolingWidget(BaseWidget, Ui_CoolingWidget):
     def checkEnabled_toggled(self, enabled: bool) -> None:
         self.spinSetPoint.setEnabled(enabled)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def buttonApply_clicked(self) -> None:
+    def buttonApply_clicked(self) -> None:
         enabled = self.checkEnabled.isChecked()
         temp = self.spinSetPoint.value()
+        self.run_background(self._apply_cooling, enabled, temp)
+
+    async def _apply_cooling(self, enabled: bool, temp: float) -> None:
         async with self.comm.proxy(self.module, ICooling) as proxy:
             await proxy.set_cooling(enabled, temp)

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/datadisplaywidget.py

@@ -20,7 +20,6 @@ from .qt.datadisplaywidget_ui import Ui_DataDisplayWidget
 
 if TYPE_CHECKING:
     from matplotlib.figure import Figure
-    from pyobs.comm import Proxy
     from matplotlib.axes import Axes
     from astropy.io import fits
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/filterwidget.py

@@ -1,6 +1,5 @@
 from typing import Any
 
-import qasync
 from PySide6 import QtWidgets, QtCore  # type: ignore
 
 from pyobs.interfaces import IFilters, FilterState, IMotion, MotionState
@@ -61,12 +60,15 @@ class FilterWidget(BaseWidget, Ui_FilterWidget):
         ]
         self.buttonSetFilter.setEnabled(initialized and self.permitted("set_filter"))
 
-    @qasync.asyncSlot()  # type: ignore
-    async def set_filter(self) -> None:
+    def set_filter(self) -> None:
         new_value, ok = QtWidgets.QInputDialog.getItem(self, "Set filter", "New filter", self._filters, 0, False)
         if ok:
-            async with self.comm.proxy(self.module, IFilters) as proxy:
-                self.run_background(proxy.set_filter, new_value)
+
+            async def _do_set_filter() -> None:
+                async with self.comm.proxy(self.module, IFilters) as proxy:
+                    await proxy.set_filter(new_value)
+
+            self.run_background(_do_set_filter)
 
 
 __all__ = ["FilterWidget"]

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/focuswidget.py

@@ -1,8 +1,6 @@
-import asyncio
 import logging
 from typing import Any
 
-import qasync  # type: ignore
 from PySide6 import QtWidgets, QtCore  # type: ignore
 
 from pyobs.interfaces import IFocuser, FocuserState, IMotion, MotionState
@@ -71,7 +69,7 @@ class FocusWidget(BaseWidget, Ui_FocusWidget):
         value = self._focus or 0.0
         new_value, ok = QtWidgets.QInputDialog.getDouble(self, "Focus", "New value", value, 0, 100, 2)
         if ok:
-            asyncio.ensure_future(self._set_focus_base_async(new_value))
+            self.run_background(self._set_focus_base_async, new_value)
 
     async def _set_focus_base_async(self, new_value: float) -> None:
         async with self.comm.proxy(self.module, IFocuser) as proxy:
@@ -81,14 +79,16 @@ class FocusWidget(BaseWidget, Ui_FocusWidget):
         value = self._focus_offset or 0.0
         new_value, ok = QtWidgets.QInputDialog.getDouble(self, "Focus offset", "New value", value, -5, 5, 2)
         if ok:
-            asyncio.ensure_future(self._set_focus_offset_async(new_value))
+            self.run_background(self._set_focus_offset_async, new_value)
 
     async def _set_focus_offset_async(self, new_value: float) -> None:
         async with self.comm.proxy(self.module, IFocuser) as proxy:
             await proxy.set_focus_offset(new_value)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _reset_focus_offset(self) -> None:
+    def _reset_focus_offset(self) -> None:
+        self.run_background(self._do_reset_focus_offset)
+
+    async def _do_reset_focus_offset(self) -> None:
         async with self.comm.proxy(self.module, IFocuser) as proxy:
             await proxy.set_focus_offset(0.0)
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/roofwidget.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from typing import Any, TYPE_CHECKING
-import qasync  # type: ignore
 from PySide6 import QtCore  # type: ignore
 
 from pyobs.interfaces import IMotion, MotionState, IPointingAltAz, AltAzState
@@ -53,17 +52,23 @@ class RoofWidget(BaseWidget, Ui_RoofWidget):
         else:
             self.labelAzimuth.setText(f"{self._azimuth:.1f}°")
 
-    @qasync.asyncSlot()  # type: ignore
-    async def open_roof(self) -> None:
+    def open_roof(self) -> None:
+        self.run_background(self._open_roof)
+
+    async def _open_roof(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.init()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def close_roof(self) -> None:
+    def close_roof(self) -> None:
+        self.run_background(self._close_roof)
+
+    async def _close_roof(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.park()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def stop_roof(self) -> None:
+    def stop_roof(self) -> None:
+        self.run_background(self._stop_roof)
+
+    async def _stop_roof(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.stop_motion()

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/spectrographwidget.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from typing import Any, TYPE_CHECKING
-import qasync  # type: ignore
 from PySide6 import QtCore  # type: ignore
 
 from pyobs.interfaces import IAbortable, IExposure, ExposureState
@@ -59,8 +58,10 @@ class SpectrographWidget(BaseWidget, Ui_SpectrographWidget):
         self.exposure_status = state.status
         self.signal_update_gui.emit()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def grab_spectrum(self) -> None:
+    def grab_spectrum(self) -> None:
+        self.run_background(self._grab_spectra)
+
+    async def _grab_spectra(self) -> None:
         broadcast = self.checkBroadcast.isChecked()
 
         # take the requested number of spectra; an exception (e.g. from a failed exposure,
@@ -72,10 +73,12 @@ class SpectrographWidget(BaseWidget, Ui_SpectrographWidget):
             self.exposures_left -= 1
             self.signal_update_gui.emit()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def abort(self) -> None:
+    def abort(self) -> None:
         # stop the sequence after the current spectrum finishes aborting
         self.exposures_left = 0
+        self.run_background(self._abort_sequence)
+
+    async def _abort_sequence(self) -> None:
         async with self.comm.proxy(self.module, IAbortable) as proxy:
             await proxy.abort()
 

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/statuswidget.py

@@ -13,7 +13,7 @@ from pyobs.events import Event, ModuleOpenedEvent, ModuleClosedEvent
 from pyobs.interfaces import IModule, Interface
 from pyobs.utils.enums import ModuleState
 from pyobs.vfs import VirtualFileSystem
-from pyobs_gui.base import BaseWidget
+from pyobs_gui.base import BaseWidget, show_remote_error
 
 log = logging.getLogger(__name__)
 
@@ -131,8 +131,11 @@ class StatusItem(QtWidgets.QWidget):
 
     @qasync.asyncSlot()  # type: ignore
     async def button_clicked(self) -> None:
-        async with self.comm.proxy(self.name, IModule) as proxy:
-            await proxy.reset_error()
+        try:
+            async with self.comm.proxy(self.name, IModule) as proxy:
+                await proxy.reset_error()
+        except Exception as e:
+            await show_remote_error(self, e)
 
 
 class StateItem(QtCore.QObject):

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/telescopewidget.py

@@ -1,9 +1,7 @@
-import asyncio
 from enum import Enum
 from typing import Any
 
 import numpy as np
-import qasync  # type: ignore
 from PySide6 import QtWidgets, QtCore  # type: ignore
 from astropy.coordinates import SkyCoord, ICRS, AltAz, get_sun, EarthLocation
 from astroplan import Observer
@@ -473,9 +471,7 @@ class TelescopeWidget(BaseWidget, Ui_TelescopeWidget):
 
             if IPointingHelioprojective in self._interfaces and self.permitted("move_helioprojective"):
                 self.run_background(self._do_move_helioprojective, heliproj.Tx.degree, heliproj.Ty.degree)
-            elif IPointingHeliographicStonyhurst in self._interfaces and self.permitted(
-                "move_heliographic_stonyhurst"
-            ):
+            elif IPointingHeliographicStonyhurst in self._interfaces and self.permitted("move_heliographic_stonyhurst"):
                 stony = heliproj.transform_to(HeliographicStonyhurst)
                 # pyrefly: ignore [missing-attribute]
                 lon, lat = float(stony.lon.to(u.degree).value), float(stony.lat.to(u.degree).value)
@@ -517,18 +513,24 @@ class TelescopeWidget(BaseWidget, Ui_TelescopeWidget):
     # Motion control slots
     # -------------------------------------------------------------------------
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _init_telescope(self) -> None:
+    def _init_telescope(self) -> None:
+        self.run_background(self._do_init)
+
+    async def _do_init(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.init()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _park_telescope(self) -> None:
+    def _park_telescope(self) -> None:
+        self.run_background(self._do_park)
+
+    async def _do_park(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.park()
 
-    @qasync.asyncSlot()  # type: ignore
-    async def _stop_telescope(self) -> None:
+    def _stop_telescope(self) -> None:
+        self.run_background(self._do_stop)
+
+    async def _do_stop(self) -> None:
         async with self.comm.proxy(self.module, IMotion) as proxy:
             await proxy.stop_motion("ITelescope")
 
@@ -539,20 +541,20 @@ class TelescopeWidget(BaseWidget, Ui_TelescopeWidget):
     @QtCore.Slot()  # type: ignore
     def _set_offset(self) -> None:
         if self.sender() == self.buttonResetHorizontalOffsets:
-            asyncio.create_task(self._do_set_offsets_altaz(0.0, 0.0))
+            self.run_background(self._do_set_offsets_altaz, 0.0, 0.0)
         elif self.sender() == self.buttonResetEquatorialOffsets:
-            asyncio.create_task(self._do_set_offsets_radec(0.0, 0.0))
+            self.run_background(self._do_set_offsets_radec, 0.0, 0.0)
         else:
             new_value, ok = QtWidgets.QInputDialog.getDouble(self, "Set offset", 'New offset ["]', 0, -9999, 9999)
             if ok:
                 if self.sender() == self.buttonSetAltOffset:
-                    asyncio.create_task(self._do_set_offsets_altaz(new_value / 3600.0, self._off_az or 0.0))
+                    self.run_background(self._do_set_offsets_altaz, new_value / 3600.0, self._off_az or 0.0)
                 elif self.sender() == self.buttonSetAzOffset:
-                    asyncio.create_task(self._do_set_offsets_altaz(self._off_alt or 0.0, new_value / 3600.0))
+                    self.run_background(self._do_set_offsets_altaz, self._off_alt or 0.0, new_value / 3600.0)
                 elif self.sender() == self.buttonSetRaOffset:
-                    asyncio.create_task(self._do_set_offsets_radec(new_value / 3600.0, self._off_dec or 0.0))
+                    self.run_background(self._do_set_offsets_radec, new_value / 3600.0, self._off_dec or 0.0)
                 elif self.sender() == self.buttonSetDecOffset:
-                    asyncio.create_task(self._do_set_offsets_radec(self._off_ra or 0.0, new_value / 3600.0))
+                    self.run_background(self._do_set_offsets_radec, self._off_ra or 0.0, new_value / 3600.0)
 
     async def _do_set_offsets_altaz(self, alt: float, az: float) -> None:
         async with self.comm.proxy(self.module, IOffsetsAltAz) as proxy:

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyobs_gui/videowidget.py

@@ -3,7 +3,6 @@ import logging
 from typing import Any
 from urllib.parse import urlparse
 
-import qasync  # type: ignore
 from astroplan import Observer
 from pyobs.comm import Comm
 from pyobs.interfaces import (
@@ -224,8 +223,10 @@ class VideoWidget(BaseWidget, Ui_VideoWidget):
             qp.loadFromData(image_data)
             self.widgetLiveView.setPixmap(qp)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def grab_image(self) -> None:
+    def grab_image(self) -> None:
+        self.run_background(self._grab_image)
+
+    async def _grab_image(self) -> None:
         # set image format
         if IImageFormat in self._interfaces:
             image_format = ImageFormat[self.comboImageFormat.currentText()]  # type: ignore[attr-defined]
@@ -239,7 +240,7 @@ class VideoWidget(BaseWidget, Ui_VideoWidget):
         self.signal_update_gui.emit()
 
         # start exposures
-        asyncio.create_task(self._expose_task_func())
+        await self._expose_task_func()
 
     async def _expose_task_func(self) -> None:
         # get image type
@@ -266,22 +267,26 @@ class VideoWidget(BaseWidget, Ui_VideoWidget):
     def abort_sequence(self) -> None:
         self.exposures_left = 0
 
-    @qasync.asyncSlot()  # type: ignore
-    async def exposure_time_changed(self) -> None:
+    def exposure_time_changed(self) -> None:
         # get exp_time
         exp_time = self.spinExpTime.value()
 
         # set it
+        self.run_background(self._set_exposure_time, exp_time)
+
+    async def _set_exposure_time(self, exp_time: float) -> None:
         if IExposureTime in self._interfaces:
             async with self.comm.proxy(self.module, IExposureTime) as proxy:
                 await proxy.set_exposure_time(exp_time)
 
-    @qasync.asyncSlot()  # type: ignore
-    async def gain_changed(self) -> None:
+    def gain_changed(self) -> None:
         # get gain
         gain = self.spinGain.value()
 
         # set it
+        self.run_background(self._set_gain, gain)
+
+    async def _set_gain(self, gain: float) -> None:
         if IGain in self._interfaces:
             async with self.comm.proxy(self.module, IGain) as proxy:
                 await proxy.set_gain(gain)

{pyobs_gui-2.0.0.dev16 → pyobs_gui-2.0.0.dev18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-gui"
-version = "2.0.0.dev16"
+version = "2.0.0.dev18"
 description = "A remote GUI for pyobs"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"