v1.5.0

version 1.5.0

Author: thusser

mypy.ini

@@ -0,0 +1,26 @@
+[mypy]
+# strict checking
+strict = True
+implicit_reexport = True
+
+# Minimum version supported
+python_version = 3.11
+
+packages=pyobs_gui
+exclude = docs/
+
+# Allows Type[T] to refer to abstract classes, which is not otherwise supported.
+# See https://github.com/python/mypy/issues/4717
+disable_error_code = type-abstract
+
+[mypy-pyobs_gui.qt.*]
+ignore_errors = true
+
+[mypy-astropy.*]
+ignore_missing_imports = True
+
+[mypy-astroplan.*]
+ignore_missing_imports = True
+
+[mypy-qasync.*]
+ignore_missing_imports = True

pyobs_gui/base.py

@@ -3,18 +3,8 @@
 import asyncio
 import logging
 from collections.abc import Coroutine
-from typing import (
-    List,
-    Dict,
-    Tuple,
-    Any,
-    Union,
-    TypeVar,
-    Optional,
-    Callable,
-)
-
-from PyQt5 import QtWidgets, QtGui, QtCore
+from typing import Any, TypeVar, Callable, Type
+from PySide6 import QtWidgets, QtGui, QtCore  # type: ignore
 from astroplan import Observer
 
 from pyobs.comm import Comm, Proxy
@@ -33,18 +23,24 @@
 class BaseWindow:
     def __init__(self) -> None:
         """Base class for MainWindow and all widgets."""
-        self.modules: List[Proxy] = []
-        self.comm: Optional[Comm] = None
-        self.observer: Optional[Observer] = None
-        self.vfs: Optional[Union[VirtualFileSystem, Dict[str, Any]]] = None
-        self._base_widgets: List[BaseWidget] = []
+        self.modules: list[Proxy] = []
+        self._comm: Comm | None = None
+        self.observer: Observer | None = None
+        self.vfs: VirtualFileSystem | dict[str, Any] | None = None
+        self._base_widgets: list[BaseWidget] = []
 
     @property
-    def module(self) -> Optional[Proxy]:
+    def comm(self) -> Comm:
+        if self._comm is None:
+            raise ValueError("No comm object.")
+        return self._comm
+
+    @property
+    def module(self) -> Proxy:
         """Returns the first module in the list or None, if list is empty"""
-        return self.modules[0] if len(self.modules) > 0 else None
+        return self.modules[0]
 
-    def module_by_name(self, name: str) -> Optional[Proxy]:
+    def module_by_name(self, name: str) -> Proxy | None:
         """Return the module with the given name or None, if not exists.
 
         Args:
@@ -62,7 +58,7 @@ def module_by_name(self, name: str) -> Optional[Proxy]:
         # nothing found
         return None
 
-    def modules_by_interface(self, interface: Any) -> List[Proxy]:
+    def modules_by_interface(self, interface: Any) -> list[Proxy]:
         """Returns all modules that implement the given interface.
 
         Args:
@@ -73,7 +69,7 @@ def modules_by_interface(self, interface: Any) -> List[Proxy]:
         """
         return list(filter(lambda m: isinstance(m, interface), self.modules))
 
-    def module_by_interface(self, interface: Any) -> Optional[Proxy]:
+    def module_by_interface(self, interface: Any) -> Proxy | None:
         """Returns first modules that implement the given interface, or None, if no exist.
 
         Args:
@@ -85,7 +81,7 @@ def module_by_interface(self, interface: Any) -> Optional[Proxy]:
         modules = self.modules_by_interface(interface)
         return None if len(modules) == 0 else modules[0]
 
-    def create_widget(self, config: Union[Dict[str, Any], type], **kwargs: Any) -> "BaseWidget":
+    def create_widget(self, config: dict[str, Any] | type, **kwargs: Any) -> "BaseWidget":
         """Creates new widget.
 
         Args:
@@ -112,37 +108,38 @@ def create_widget(self, config: Union[Dict[str, Any], type], **kwargs: Any) -> "
 
     async def open(
         self,
-        modules: Optional[List[Proxy]] = None,
-        comm: Optional[Comm] = None,
-        observer: Optional[Observer] = None,
-        vfs: Optional[Union[VirtualFileSystem, Dict[str, Any]]] = None,
+        modules: list[Proxy] | None = None,
+        comm: Comm | None = None,
+        observer: Observer | None = None,
+        vfs: VirtualFileSystem | dict[str, Any] | None = None,
     ) -> None:
         # store
         self.modules = [] if modules is None else modules
         self.vfs = vfs
-        self.comm = comm
+        self._comm = comm
         self.observer = observer
 
         """Open all widgets."""
         for widget in self._base_widgets:
             await self._open_child(widget)
 
-    async def _open_child(self, widget: BaseWidget):
+    async def _open_child(self, widget: BaseWidget) -> None:
         await widget.open(modules=self.modules, vfs=self.vfs, comm=self.comm, observer=self.observer)
 
 
-class BaseWidget(BaseWindow):
-    _show_error = QtCore.pyqtSignal(str)
-    _enable_buttons = QtCore.pyqtSignal(list, bool)
+class BaseWidget(BaseWindow, QtWidgets.QWidget):  # type: ignore
+    _show_error = QtCore.Signal(str)
+    _enable_buttons = QtCore.Signal(list, bool)
 
     def __init__(
         self,
-        update_func: Optional[Callable[[], Any]] = None,
+        update_func: Callable[[], Any] | None = None,
         update_interval: float = 1,
         *args: Any,
         **kwargs: Any,
     ):
         BaseWindow.__init__(self)
+        QtWidgets.QWidget.__init__(self)
 
         # signals
         self._show_error.connect(self.show_error)
@@ -151,15 +148,15 @@ def __init__(
         # update
         self._update_func = update_func
         self._update_interval = update_interval
-        self._update_task: Optional[Any] = None
+        self._update_task: Any | None = None
 
         # sidebar
-        self.sidebar_widgets: List[BaseWidget] = []
-        self.sidebar_layout: Optional[QtWidgets.QVBoxLayout] = None
+        self.sidebar_widgets: list[BaseWidget] = []
+        self.sidebar_layout: QtWidgets.QVBoxLayout | None = None
 
         # button to extract to window
-        self.extract_window_button: Optional[QtWidgets.QToolButton] = None
-        self._windows: List[QtWidgets.QDialog] = []
+        self.extract_window_button: QtWidgets.QToolButton | None = None
+        self._windows: list[QtWidgets.QDialog] = []
 
         # has it been initialized?
         self._initialized = False
@@ -168,18 +165,18 @@ def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
         if self.extract_window_button:
             self.extract_window_button.move(self.width() - 20, 0)
 
-    def show_extract_button(self, klass, title):
+    def show_extract_button(self, klass: Type[Any], title: str) -> None:
         # button to extract to window
         self.extract_window_button = QtWidgets.QToolButton(self)
         # self.extract_window_button.setText("X")
         self.extract_window_button.setIcon(QtGui.QIcon(":/resources/arrow-up-right-from-square-solid.svg"))
-        self.colorize_button(self.extract_window_button, QtCore.Qt.darkCyan)
+        self.colorize_button(self.extract_window_button, QtCore.Qt.GlobalColor.darkCyan)
         self.extract_window_button.move(self.width() - 20, 0)
         self.extract_window_button.resize(20, 20)
         self.extract_window_button.raise_()
 
         # method for creating new window
-        def create_window():
+        def create_window() -> None:
             # create dialog and add widget
             dialog = QtWidgets.QDialog()
             dialog.setWindowTitle(title)
@@ -203,9 +200,12 @@ async def add_to_sidebar(self, widget: BaseWidget) -> None:
         if self.sidebar_layout is None:
             self.sidebar_layout = QtWidgets.QVBoxLayout()
             self.sidebar_layout.setContentsMargins(0, 0, 0, 0)
-            spacer_item = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+            spacer_item = QtWidgets.QSpacerItem(
+                20, 40, QtWidgets.QSizePolicy.Policy.Minimum, QtWidgets.QSizePolicy.Policy.Expanding
+            )
             self.sidebar_layout.addItem(spacer_item)
-            self.widgetSidebar.setLayout(self.sidebar_layout)
+            if hasattr(self, "widgetSidebar"):
+                self.widgetSidebar.setLayout(self.sidebar_layout)
 
         # open it
         await self._open_child(widget)
@@ -246,8 +246,9 @@ async def _update_loop(self) -> None:
         while True:
             try:
                 # get module state
-                if isinstance(self.module, IModule):
-                    state = await self.module.get_state()
+                module = self.module
+                if isinstance(module, IModule):
+                    state = await module.get_state()
                     self.setEnabled(state == ModuleState.READY)
                     if state != ModuleState.READY:
                         return
@@ -259,7 +260,7 @@ async def _update_loop(self) -> None:
                 # sleep a little
                 await asyncio.sleep(1)
 
-            except exc.PyObsError:
+            except (exc.PyObsError, IndexError):
                 # ignore these and sleep a little
                 await asyncio.sleep(1)
 
@@ -292,11 +293,11 @@ async def show_error(self, exception: exc.PyObsError) -> None:
         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:
+    def enable_buttons(self, widgets: list[QtWidgets.QWidget], enable: bool) -> None:
         for w in widgets:
             w.setEnabled(enable)
 
-    def get_fits_headers(self, namespaces: Optional[List[str]] = None, **kwargs: Any) -> Dict[str, Tuple[Any, str]]:
+    def get_fits_headers(self, namespaces: list[str] | None = None, **kwargs: Any) -> dict[str, tuple[Any, str]]:
         """Returns FITS header for the current status of this module.
 
         Args:
@@ -311,19 +312,20 @@ def get_fits_headers(self, namespaces: Optional[List[str]] = None, **kwargs: Any
                 hdr[k] = v
         return hdr
 
-    def colorize_button(self, button: Any, background: Any, black_on_white: bool = True) -> None:
+    @staticmethod
+    def colorize_button(button: Any, background: Any, black_on_white: bool = True) -> None:
         # get palette
         pal = button.palette()
 
         # change active colors
-        pal.setColor(QtGui.QPalette.Button, background)
+        pal.setColor(QtGui.QPalette.ColorRole.Button, background)
         pal.setColor(
-            QtGui.QPalette.ButtonText,
-            QtCore.Qt.black if black_on_white else QtCore.Qt.white,
+            QtGui.QPalette.ColorRole.ButtonText,
+            QtCore.Qt.GlobalColor.black if black_on_white else QtCore.Qt.GlobalColor.white,
         )
 
         # change disabled colors
-        pal.setColor(QtGui.QPalette.Disabled, QtGui.QPalette.Button, QtCore.Qt.gray)
+        pal.setColor(QtGui.QPalette.ColorGroup.Disabled, QtGui.QPalette.ColorRole.Button, QtCore.Qt.GlobalColor.gray)
 
         # set palette again
         button.setPalette(pal)