pyobs-gui 1.8.7__tar.gz → 2.0.0.dev1__tar.gz

pyobs_gui-2.0.0.dev1/.github/workflows/pyrefly.yml

@@ -0,0 +1,23 @@
+name: pyrefly
+on: push
+
+jobs:
+  pyrefly:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          python-version: "3.13"
+
+      - name: Install packages
+        run: uv sync --all-extras --dev
+
+      - name: Run pyrefly
+        run: uv run pyrefly check

pyobs_gui-2.0.0.dev1/.github/workflows/ruff.yml

@@ -0,0 +1,23 @@
+name: ruff
+on: push
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          python-version: "3.13"
+
+      - name: Install packages
+        run: uv sync --all-extras --dev
+
+      - name: Run ruff
+        run: uv run ruff check pyobs_gui/

{pyobs_gui-1.8.7 → pyobs_gui-2.0.0.dev1}/.pre-commit-config.yaml

@@ -9,7 +9,14 @@ repos:
         # pre-commit's default_language_version, see
         # https://pre-commit.com/#top_level-default_language_version
         language_version: python3.11
-  - repo: https://github.com/pycqa/flake8
-    rev: '7.3.0'  # pick a git hash / tag to point to
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.0
     hooks:
-    - id: flake8
+      - id: ruff
+  - repo: local
+    hooks:
+      - id: pyrefly
+        name: pyrefly
+        entry: uv run pyrefly check
+        language: system
+        pass_filenames: false

{pyobs_gui-1.8.7 → pyobs_gui-2.0.0.dev1}/PKG-INFO

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: pyobs-gui
-Version: 1.8.7
+Version: 2.0.0.dev1
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: <3.14,>=3.11
+Requires-Dist: astroplan>=0.10.1
+Requires-Dist: astropy<8,>=7.0.1
 Requires-Dist: colour<0.2,>=0.1.5
 Requires-Dist: matplotlib<4,>=3.10.1
-Requires-Dist: pyobs-core<2,>=1.49.0
+Requires-Dist: pyobs-core<3,>=2.0.0.dev6
 Requires-Dist: pyside6>=6.10.1
 Requires-Dist: qasync<0.28,>=0.27.1
 Requires-Dist: qfitswidget>=0.13.1

{pyobs_gui-1.8.7 → pyobs_gui-2.0.0.dev1}/pyobs_gui/base.py

@@ -2,28 +2,31 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from collections.abc import Coroutine
-from typing import Any, TypeVar, Callable, Type
-from PySide6 import QtWidgets, QtGui, QtCore  # type: ignore
-from astroplan import Observer
+from typing import TYPE_CHECKING, Any, Callable, Type, TypeVar, overload
 
-from pyobs.comm import Comm, Proxy
-from pyobs.interfaces import IModule
+import pyobs.utils.exceptions as exc
 from pyobs.object import create_object
 from pyobs.utils.enums import ModuleState
-from pyobs.vfs import VirtualFileSystem
-import pyobs.utils.exceptions as exc
+from PySide6 import QtCore, QtGui, QtWidgets  # type: ignore
+
 from .utils import QAsyncMessageBox
 
+if TYPE_CHECKING:
+    from collections.abc import Coroutine
+
+    from astroplan import Observer
+    from pyobs.comm import Comm
+    from pyobs.vfs import VirtualFileSystem
+
 log = logging.getLogger(__name__)
 
-WidgetClass = TypeVar("WidgetClass")
+WidgetClass = TypeVar("WidgetClass", bound="BaseWidget")
 
 
 class BaseWindow:
     def __init__(self) -> None:
         """Base class for MainWindow and all widgets."""
-        self.modules: list[Proxy] = []
+        self.modules: list[str] = []
         self._comm: Comm | None = None
         self.observer: Observer | None = None
         self.vfs: VirtualFileSystem | dict[str, Any] | None = None
@@ -36,29 +39,11 @@ class BaseWindow:
         return self._comm
 
     @property
-    def module(self) -> Proxy:
+    def module(self) -> str:
         """Returns the first module in the list or None, if list is empty"""
         return self.modules[0]
 
-    def module_by_name(self, name: str) -> Proxy | None:
-        """Return the module with the given name or None, if not exists.
-
-        Args:
-            name: Name of module to return.
-
-        Returns:
-            Module or None.
-        """
-
-        # loop all modules and check name
-        for module in self.modules:
-            if module.name == name:
-                return module
-
-        # nothing found
-        return None
-
-    def modules_by_interface(self, interface: Any) -> list[Proxy]:
+    def modules_by_interface(self, interface: Any) -> list[str]:
         """Returns all modules that implement the given interface.
 
         Args:
@@ -69,7 +54,7 @@ class BaseWindow:
         """
         return list(filter(lambda m: isinstance(m, interface), self.modules))
 
-    def module_by_interface(self, interface: Any) -> Proxy | None:
+    def module_by_interface(self, interface: Any) -> str | None:
         """Returns first modules that implement the given interface, or None, if no exist.
 
         Args:
@@ -81,6 +66,10 @@ class BaseWindow:
         modules = self.modules_by_interface(interface)
         return None if len(modules) == 0 else modules[0]
 
+    @overload
+    def create_widget(self, config: type[WidgetClass], **kwargs: Any) -> WidgetClass: ...
+    @overload
+    def create_widget(self, config: dict[str, Any], **kwargs: Any) -> "BaseWidget": ...
     def create_widget(self, config: dict[str, Any] | type, **kwargs: Any) -> "BaseWidget":
         """Creates new widget.
 
@@ -108,7 +97,7 @@ class BaseWindow:
 
     async def open(
         self,
-        modules: list[Proxy] | None = None,
+        modules: list[str] | None = None,
         comm: Comm | None = None,
         observer: Observer | None = None,
         vfs: VirtualFileSystem | dict[str, Any] | None = None,
@@ -247,8 +236,9 @@ class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
             try:
                 # get module state
                 module = self.module
-                if isinstance(module, IModule):
-                    state = await module.get_state()
+                client_state = self.comm.get_client_state(module)
+                if client_state is not None:
+                    state, _ = client_state
                     self.setEnabled(state == ModuleState.READY)
                     if state != ModuleState.READY:
                         return

pyobs_gui-2.0.0.dev1/pyobs_gui/camerawidget.py

@@ -0,0 +1,307 @@
+import logging
+from typing import Any
+import qasync  # type: ignore
+from PySide6 import QtWidgets, QtCore  # type: ignore
+from astroplan import Observer
+
+from pyobs.comm import Comm
+from pyobs.events import NewImageEvent
+from pyobs.interfaces import (
+    IAbortable,
+    IExposureTime,
+    ExposureTimeState,
+    IImageType,
+    ImageTypeState,
+    IImageFormat,
+    ImageFormatState,
+    IBinning,
+    BinningState,
+    IWindow,
+    WindowState,
+    IFilters,
+    ICooling,
+    ITemperatures,
+    IGain,
+    GainState,
+    IExposure,
+    ExposureState,
+)
+from pyobs.utils.enums import ImageType, ImageFormat, ExposureStatus
+from pyobs.vfs import VirtualFileSystem
+from .base import BaseWidget
+from .coolingwidget import CoolingWidget
+from .filterwidget import FilterWidget
+from .temperatureswidget import TemperaturesWidget
+from .fitsheaderswidget import FitsHeadersWidget
+from .qt.camerawidget_ui import Ui_CameraWidget
+
+log = logging.getLogger(__name__)
+
+
+class CameraWidget(BaseWidget, Ui_CameraWidget):
+    signal_update_gui = QtCore.Signal()
+    signal_new_image = QtCore.Signal(NewImageEvent, str)
+
+    def __init__(self, **kwargs: Any):
+        BaseWidget.__init__(self, **kwargs)
+        self.setupUi(self)  # type: ignore
+
+        # variables
+        self.new_image = False
+        self.image_filename = None
+        self.image = None
+        self.status = None
+        self.exposure_status = ExposureStatus.IDLE
+        self.exposures_left = 0
+        self.exposure_time_left = 0.0
+        self.exposure_progress = 0.0
+
+        self.spinWindowLeft.init_modified(self.labelWindowLeft).committed.connect(self._window_changed)
+        self.spinWindowTop.init_modified(self.labelWindowTop).committed.connect(self._window_changed)
+        self.spinWindowWidth.init_modified(self.labelWindowWidth).committed.connect(self._window_changed)
+        self.spinWindowHeight.init_modified(self.labelWindowHeight).committed.connect(self._window_changed)
+        self.spinGain.init_modified(self.labelGain).committed.connect(self._gain_changed)
+        self.spinGainOffset.init_modified(self.labelGain).committed.connect(self._gain_changed)
+
+    async def open(
+        self,
+        modules: list[str] | None = None,
+        comm: Comm | None = None,
+        observer: Observer | None = None,
+        vfs: VirtualFileSystem | dict[str, Any] | None = None,
+    ) -> None:
+        """Open module."""
+        await BaseWidget.open(self, modules=modules, comm=comm, observer=observer, vfs=vfs)
+        await self.datadisplay.open(modules=modules, comm=comm, observer=observer, vfs=vfs)
+
+        # set exposure types
+        image_types = sorted([it.name for it in ImageType])
+        self.comboImageType.addItems(image_types)
+
+        # before first update, disable mys
+        self.setEnabled(False)
+
+        # hide groups, if necessary
+        self.groupWindowing.setVisible(await self.comm.has_proxy(self.module, IWindow))
+        self.groupBinning.setVisible(await self.comm.has_proxy(self.module, IBinning))
+        self.groupImageFormat.setVisible(await self.comm.has_proxy(self.module, IImageFormat))
+        self.groupExpTime.setVisible(await self.comm.has_proxy(self.module, IExposureTime))
+        self.groupGain.setVisible(await self.comm.has_proxy(self.module, IGain))
+
+        # and single controls
+        self.labelImageType.setVisible(await self.comm.has_proxy(self.module, IImageType))
+        self.comboImageType.setVisible(await self.comm.has_proxy(self.module, IImageType))
+        self.butAbort.setVisible(await self.comm.has_proxy(self.module, IAbortable))
+
+        # initial values
+        self.comboImageType.setCurrentIndex(image_types.index("OBJECT"))
+
+        # connect signals
+        self.signal_update_gui.connect(self.update_gui)
+        self.butFullFrame.clicked.connect(self.set_full_frame)
+        self.comboBinning.currentTextChanged.connect(self.set_full_frame)
+        self.checkBroadcast.stateChanged.connect(self.broadcast_changed)
+        self.comboImageType.currentTextChanged.connect(self.image_type_changed)
+        self.butExpose.clicked.connect(self.expose)
+        self.butAbort.clicked.connect(self.abort)
+
+        # fill sidebar
+        await self.add_to_sidebar(self.create_widget(FitsHeadersWidget, module=self.module))
+        if await self.comm.has_proxy(self.module, IFilters):
+            await self.add_to_sidebar(self.create_widget(FilterWidget, module=self.module))
+        if await self.comm.has_proxy(self.module, ICooling):
+            await self.add_to_sidebar(self.create_widget(CoolingWidget, module=self.module))
+        if await self.comm.has_proxy(self.module, ITemperatures):
+            await self.add_to_sidebar(self.create_widget(TemperaturesWidget, module=self.module))
+
+    async def _init(self) -> None:
+        # window
+        async with self.comm.safe_proxy(self.module, IWindow) as proxy:
+            if proxy is not None:
+                await self.comm.subscribe_state(self.module, IWindow, self._update_window)
+                await self.set_full_frame()
+
+        # binning
+        binning_caps = await self.comm.get_capabilities(self.module, IBinning)
+        if binning_caps is not None:
+            binnings = [f"{b.x}x{b.y}" for b in binning_caps.binnings]
+            self.comboBinning.clear()
+            self.comboBinning.addItems(binnings)
+            await self.comm.subscribe_state(self.module, IBinning, self._update_binning)
+
+        # gain — initial values delivered by subscription callback
+        if await self.comm.has_proxy(self.module, IGain):
+            await self.comm.subscribe_state(self.module, IGain, self._update_gain)
+
+        # image format
+        image_format_caps = await self.comm.get_capabilities(self.module, IImageFormat)
+        if image_format_caps is not None:
+            image_formats = [ImageFormat(f) for f in image_format_caps.image_formats]
+            self.comboImageFormat.clear()
+            self.comboImageFormat.addItems([f.name for f in image_formats])
+            await self.comm.subscribe_state(self.module, IImageFormat, self._update_image_format)
+
+        async with self.comm.safe_proxy(self.module, IImageType) as proxy:
+            if proxy is not None:
+                await self.comm.subscribe_state(self.module, IImageType, self._update_image_type)
+
+        async with self.comm.safe_proxy(self.module, IExposure) as proxy:
+            if proxy is not None:
+                await self.comm.subscribe_state(self.module, IExposure, self._update_exposure)
+
+        async with self.comm.safe_proxy(self.module, IExposureTime) as proxy:
+            if proxy is not None:
+                await self.comm.subscribe_state(self.module, IExposureTime, self._update_exposure_time)
+
+        # update GUI
+        self.signal_update_gui.emit()
+
+    def _update_window(self, state: WindowState):
+        self.labelWindowLeft.setText(str(state.x))
+        self.labelWindowTop.setText(str(state.y))
+        self.labelWindowWidth.setText(str(state.width))
+        self.labelWindowHeight.setText(str(state.height))
+
+    def _update_binning(self, state: BinningState):
+        self.comboBinning.setCurrentText(f"{state.x}x{state.y}")
+
+    def _update_gain(self, state: GainState):
+        self.labelGain.setText(str(state.gain))
+        self.labelGainOffset.setText(str(state.offset))
+
+    def _update_image_format(self, state: ImageFormatState):
+        self.comboImageFormat.setCurrentText(state.image_format.name)
+
+    def _update_image_type(self, state: ImageTypeState):
+        self.comboImageType.setCurrentText(state.image_type.name)
+
+    def _update_exposure(self, state: ExposureState):
+        self.exposure_status = state.status
+        self.exposure_progress = state.progress
+        self.exposure_time_left = state.exposure_time_left
+        self.update_gui()
+
+    def _update_exposure_time(self, state: ExposureTimeState):
+        self.spinExpTime.setValue(state.exposure_time)
+        self.update_gui()
+
+    @qasync.asyncSlot()
+    async def _window_changed(self):
+        print("ok")
+
+    @qasync.asyncSlot()
+    async def _gain_changed(self):
+        print("ok")
+
+    @qasync.asyncSlot()  # type: ignore
+    async def set_full_frame(self) -> None:
+        caps = await self.comm.get_capabilities(self.module, IWindow)
+        if caps is not None:
+            # get binning
+            binning = 1
+            if self.comboBinning.count() > 0 and await self.comm.has_proxy(self.module, IBinning):
+                binning = int(self.comboBinning.currentText()[0])
+
+            # max values
+            self.spinWindowLeft.setMaximum(int(caps.full_frame_width / binning))
+            self.spinWindowTop.setMaximum(int(caps.full_frame_height / binning))
+            self.spinWindowWidth.setMaximum(int(caps.full_frame_width / binning))
+            self.spinWindowHeight.setMaximum(int(caps.full_frame_height / binning))
+
+            # set it
+            self.spinWindowLeft.setValue(caps.full_frame_x)
+            self.spinWindowTop.setValue(caps.full_frame_y)
+            self.spinWindowWidth.setValue(int(caps.full_frame_width / binning))
+            self.spinWindowHeight.setValue(int(caps.full_frame_height / binning))
+
+    @QtCore.Slot(int)  # type: ignore
+    def broadcast_changed(self, state: int) -> None:
+        if state == 0:
+            r = QtWidgets.QMessageBox.question(
+                self,
+                "pyobs",
+                "When disabling the broadcast, new images will not processed (and "
+                "saved) within the pyobs network. Continue?",
+                QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
+                QtWidgets.QMessageBox.StandardButton.No,
+            )
+            if r == QtWidgets.QMessageBox.StandardButton.No:
+                self.checkBroadcast.setChecked(True)
+
+    @QtCore.Slot(str)  # type: ignore
+    def image_type_changed(self, image_type: str) -> None:
+        if image_type == "BIAS":
+            self.spinExpTime.setValue(0)
+            self.spinExpTime.setEnabled(False)
+        else:
+            self.spinExpTime.setEnabled(True)
+
+    @qasync.asyncSlot()  # type: ignore
+    async def expose(self) -> None:
+        # set initial image count
+        self.exposures_left = self.spinCount.value()
+
+        # do exposure(s)
+        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
+    async def abort(self) -> None:
+        """Abort exposure."""
+        # do we have a running exposure?
+        if self.exposures_left == 0:
+            return
+
+        # got exposures left?
+        if self.exposures_left > 1:
+            # abort sequence
+            self.exposures_left = 0
+        else:
+            async with self.comm.safe_proxy(self.module, IAbortable) as proxy:
+                if proxy is not None:
+                    await proxy.abort()
+
+    def update_gui(self) -> None:
+        """Update the GUI."""
+
+        # enable myself
+        self.setEnabled(True)
+
+        # enable/disable buttons
+        self.butExpose.setEnabled(self.exposure_status == ExposureStatus.IDLE)
+        self.butAbort.setEnabled(self.exposure_status != ExposureStatus.IDLE)
+
+        # set abort text
+        if self.exposures_left > 1:
+            self.butAbort.setText("Abort sequence")
+        else:
+            self.butAbort.setText("Abort exposure")
+
+        # set progress
+        msg = ""
+        if self.exposure_status == ExposureStatus.IDLE:
+            self.progressExposure.setValue(0)
+            msg = "IDLE"
+        elif self.exposure_status == ExposureStatus.EXPOSING:
+            self.progressExposure.setValue(int(self.exposure_progress))
+            msg = "EXPOSING %.1fs" % self.exposure_time_left
+        elif self.exposure_status == ExposureStatus.READOUT:
+            self.progressExposure.setValue(100)
+            msg = "READOUT"
+
+        # set message
+        self.labelStatus.setText(msg)
+
+        # exposures left
+        if self.exposures_left > 0:
+            self.labelExposuresLeft.setText("%d exposure(s) left" % self.exposures_left)
+        else:
+            self.labelExposuresLeft.setText("")

{pyobs_gui-1.8.7 → pyobs_gui-2.0.0.dev1}/pyobs_gui/commandinputwidget.py

@@ -13,7 +13,7 @@ class CommandInputWidget(QtWidgets.QLineEdit):  # type: ignore
     def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
         if event.key() == QtCore.Qt.Key.Key_Return:
             # get command
-            cmd = str(self.text())
+            cmd = self.text()
             # emit command
             self.commandExecuted.emit(cmd)
             # clear text field

{pyobs_gui-1.8.7 → pyobs_gui-2.0.0.dev1}/pyobs_gui/compassmovewidget.py

@@ -1,6 +1,5 @@
 from typing import Any
 from PySide6 import QtWidgets, QtCore  # type: ignore
-import qasync  # type: ignore
 import astropy.units as u
 from astropy.coordinates import SkyCoord, ICRS
 
@@ -33,20 +32,30 @@ class CompassMoveWidget(BaseWidget, Ui_CompassMoveWidget):
         self.run_background(self.__move_offset, self.sender())
 
     async def __move_offset(self, sender: QtWidgets.QWidget) -> None:
+        if self.observer is None:
+            return
+
         # get offsets
-        if isinstance(self.module, IOffsetsAltAz) and isinstance(self.module, IPointingAltAz):
-            alt, az = await self.module.get_altaz()
+        altaz = None
+        has_offsets_altaz = await self.comm.has_proxy(self.module, IOffsetsAltAz)
+        has_pointing_altaz = await self.comm.has_proxy(self.module, IPointingAltAz)
+        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 = SkyCoord(
-                alt=alt * u.degree,
-                az=alt * u.degree,
+                alt=alt * u.degree,  # type: ignore[attr-defined]
+                az=az * u.degree,  # type: ignore[attr-defined]
                 obstime=Time.now(),
                 location=self.observer.location,
                 frame="altaz",
             )
-            off_alt, off_az = await self.module.get_offsets_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)
-        elif isinstance(self.module, IOffsetsRaDec):
-            off_ra, off_dec = await self.module.get_offsets_radec()
+        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]
         else:
             return
 
@@ -64,11 +73,13 @@ class CompassMoveWidget(BaseWidget, Ui_CompassMoveWidget):
             off_ra -= user_offset
 
         # move
-        if isinstance(self.module, IOffsetsRaDec):
-            self.run_background(self.module.set_offsets_radec, off_ra, off_dec)
-        elif isinstance(self.module, IOffsetsAltAz):
-            off_alt, off_az = offset_radec_to_altaz(altaz.transform_to(ICRS()), off_ra, off_dec, self.observer.location)
-            self.run_background(self.module.set_offsets_altaz, off_alt, off_az)
+        if has_offsets_radec:
+            async with self.comm.proxy(self.module, IOffsetsRaDec) as p:
+                await p.set_offsets_radec(off_ra, off_dec)
+        elif has_offsets_altaz and altaz is not None:
+            off_alt, off_az = offset_radec_to_altaz(altaz.transform_to(ICRS()), off_ra, off_dec, self.observer.location)  # noqa: E501
+            async with self.comm.proxy(self.module, IOffsetsAltAz) as p:
+                await p.set_offsets_altaz(off_alt, off_az)
         else:
             raise ValueError
 

pyobs_gui-2.0.0.dev1/pyobs_gui/coolingwidget.py

@@ -0,0 +1,55 @@
+import qasync
+import logging
+from typing import Any
+from PySide6 import QtCore  # type: ignore
+
+from pyobs.interfaces import ICooling, CoolingState
+from .base import BaseWidget
+from .qt.coolingwidget_ui import Ui_CoolingWidget
+
+log = logging.getLogger(__name__)
+
+
+class CoolingWidget(BaseWidget, Ui_CoolingWidget):
+    signal_update_gui = QtCore.Signal()
+
+    def __init__(self, **kwargs: Any):
+        BaseWidget.__init__(self, **kwargs)
+        self.setupUi(self)  # type: ignore
+
+        # state
+        self.state: CoolingState | None = None
+
+        # connect signals
+        self.signal_update_gui.connect(self.update_gui)
+        self.checkEnabled.toggled.connect(self.checkEnabled_toggled)
+        self.buttonApply.clicked.connect(self.buttonApply_clicked)
+
+    async def _init(self) -> None:
+        await self.comm.subscribe_state(self.module, ICooling, self._update_state)
+
+    def _update_state(self, state: CoolingState) -> None:
+        self.state = state
+        self.signal_update_gui.emit()
+
+    def update_gui(self) -> None:
+        if self.state is not None:
+            self.setEnabled(True)
+
+            if self.state.enabled:
+                self.labelStatus.setText("N/A" if self.state.setpoint is None else f"{self.state.setpoint:.1f}°C")
+                self.labelPower.setText("N/A" if self.state.power is None else f"{self.state.power:d}%")
+            else:
+                self.labelStatus.setText("OFF")
+                self.labelPower.clear()
+
+    @QtCore.Slot(bool)  # type: ignore
+    def checkEnabled_toggled(self, enabled: bool) -> None:
+        self.spinSetPoint.setEnabled(enabled)
+
+    @qasync.asyncSlot()  # type: ignore
+    async def buttonApply_clicked(self) -> None:
+        enabled = self.checkEnabled.isChecked()
+        temp = self.spinSetPoint.value()
+        async with self.comm.proxy(self.module, ICooling) as proxy:
+            await proxy.set_cooling(enabled, temp)