pyobs-gui 2.0.0.dev4__tar.gz → 2.0.0.dev6__tar.gz

{pyobs_gui-2.0.0.dev4 → pyobs_gui-2.0.0.dev6}/.claude/skills/verify/SKILL.md

@@ -6,7 +6,7 @@ description: Drive the real pyobs-gui app headlessly against a real pyobs module
 # Verifying pyobs-gui changes
 
 pyobs-gui is a PySide6 app that talks to pyobs modules over `Comm`. There's no
-pytest suite (see `DEVELOPMENT.md`) — verification means running the real
+pytest suite — verification means running the real
 `GUI` module against a real target module and observing widget state /
 screenshots. This works headlessly, no Xvfb needed.
 

pyobs_gui-2.0.0.dev6/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+
+# pyside6-deploy build output for the spikes in spike_standalone/ -- generated, not source
+spike_standalone/deployment/
+spike_standalone/*.dist/
+spike_standalone/build*.log
+spike_standalone/spike_results.txt
+
+# pyside6-deploy build output for the real app -- generated, not source
+deployment/
+dist/
+build*.log

{pyobs_gui-2.0.0.dev4 → pyobs_gui-2.0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobs-gui
-Version: 2.0.0.dev4
+Version: 2.0.0.dev6
 Summary: A remote GUI for pyobs
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT
@@ -9,10 +9,12 @@ 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: keyring<26,>=25.7.0
 Requires-Dist: matplotlib<4,>=3.10.1
-Requires-Dist: pyobs-core<3,>=2.0.0.dev28
+Requires-Dist: pyobs-core<3,>=2.0.0.dev50
 Requires-Dist: pyside6>=6.10.1
 Requires-Dist: qasync<0.29,>=0.27.1
 Requires-Dist: qfitswidget>=0.13.1
 Requires-Dist: qtawesome<2,>=1.4.0
+Requires-Dist: secretstorage<4,>=3.5.0
 Requires-Dist: sunpy[all]>=7.0.1

{pyobs_gui-2.0.0.dev4 → pyobs_gui-2.0.0.dev6}/pyobs_gui/__init__.py

@@ -4,6 +4,10 @@ TODO: write doc
 
 __title__ = "GUI"
 
+from ._nuitka_astropy_patch import patch_generic_unit_parser
+
+patch_generic_unit_parser()
+
 from .gui import GUI
 from .camerawidget import CameraWidget
 from .datadisplaywidget import DataDisplayWidget

pyobs_gui-2.0.0.dev6/pyobs_gui/__main__.py

@@ -0,0 +1,21 @@
+"""Standalone entry point for an interactive-login pyobs-gui -- bypasses the config-file-driven
+`pyobs` CLI entirely. This is what a compiled binary (see
+specs/plans/gui-widget-plugins-and-packaging.md) targets: no YAML config, no credentials on disk
+unless the user opts into "store password" in the login window.
+"""
+
+from __future__ import annotations
+
+
+def main() -> None:
+    from pyobs.application import Application
+
+    from .gui import GUI
+    from .login import login_and_build_gui
+
+    app = Application(module_factory=login_and_build_gui, loop_module_class=GUI)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

pyobs_gui-2.0.0.dev6/pyobs_gui/_nuitka_astropy_patch.py

@@ -0,0 +1,453 @@
+"""Work around a Nuitka/astropy incompatibility that breaks unit-string parsing in the
+compiled standalone binary (see specs/plans/gui-widget-plugins-and-packaging.md).
+
+astropy.units.format.generic builds its PLY grammar by having ``astropy.extern.ply.yacc``/
+``lex`` walk the call stack with ``sys._getframe()`` to auto-discover the ``tokens``/``p_*``/
+``t_*`` local variables defined inside ``Generic._parser``/``Generic._lexer``. Nuitka-compiled
+function frames don't populate ``f_locals`` the way CPython's interpreted frames do, so that
+walk finds no grammar and the very first ``import astropy.units`` (pulled in unconditionally by
+pyobs-core's ``pyobs.utils.enums``) crashes with ``YaccError: Unable to build parser``. This is a
+real, unresolved upstream limitation as of 2026-07, not a pyobs bug:
+https://github.com/astropy/astropy/issues/15069
+https://github.com/Nuitka/Nuitka/issues/2313
+
+Fix: patch ``astropy.extern.ply.yacc.get_caller_module_dict``/``...lex.get_caller_module_dict``
+(the two functions actually doing the broken frame walk) so that whenever the walk comes back
+without a ``tokens`` entry, they fall back to a namespace we rebuild here from the same grammar
+(copied verbatim from astropy.units.format.generic), handed to PLY in a way that doesn't need
+frame introspection at all.
+
+This has to patch at the ``astropy.extern.ply`` level, not by importing
+``astropy.units.format.generic`` and monkeypatching ``Generic`` directly, because of a
+bootstrapping deadlock: merely importing ``astropy.units.core``/``astropy.units.format.generic``
+runs ``astropy/units/__init__.py``, which (via ``astropy.units.astrophys``, defining physical
+constants) *already* triggers the broken parser during that very import -- before a class-level
+patch could ever be installed. Patching ``get_caller_module_dict`` needs only
+``astropy.extern.ply``, which has no dependency on ``astropy.units`` at all, so it's safe to
+install before anything touches ``astropy.units``. The vendored grammar's own reference to
+``astropy.units.core.Unit``/``CompositeUnit``/``Generic`` is resolved lazily, only when the
+fallback actually fires -- by then we're already being called from inside
+``Generic._parser``/``_lexer``'s own call chain, so those names are guaranteed importable.
+
+Scoped to the generic unit format only -- the one format pyobs_gui is known to hit
+unconditionally at startup. astropy's cds/ogip/vounit formats and astropy.coordinates.angles use
+the same PLY pattern and would need the identical treatment if/when they're actually exercised in
+the compiled binary.
+
+Must run before ``astropy.units`` is imported anywhere, i.e. as the first thing in
+``pyobs_gui/__init__.py``.
+"""
+
+from __future__ import annotations
+
+import re
+import tempfile
+import types
+from fractions import Fraction
+from pathlib import Path
+from typing import Any
+
+_generic_ns_cache: dict[str, types.ModuleType] = {}
+
+
+def _build_generic_grammar_namespace() -> types.ModuleType:
+    """Rebuild astropy.units.format.generic's PLY grammar as a plain namespace object.
+
+    Only called lazily, from inside the ``get_caller_module_dict`` fallback below -- by that
+    point ``astropy.units.core``/``astropy.units.format.generic`` are already far enough along
+    to import from (see module docstring).
+    """
+    from astropy.units.core import CompositeUnit, Unit
+    from astropy.units.format.generic import Generic
+
+    cls = Generic
+    tokens = cls._tokens
+
+    # astropy.utils.parsing wants to write a generated tab-file cache next to __file__'s
+    # directory. In a frozen binary, astropy/units/format/ isn't a real directory on disk (it's
+    # compiled into the binary), so point this at a writable scratch directory instead --
+    # writing there is harmless best-effort caching, not required for parsing to work.
+    stub_dir = Path(tempfile.gettempdir()) / "pyobs_gui_astropy_ply_stub"
+    stub_dir.mkdir(parents=True, exist_ok=True)
+
+    ns = types.ModuleType("_pyobs_gui_generic_grammar")
+    ns.__file__ = str(stub_dir / "generic.py")
+    ns.tokens = tokens
+
+    ns.t_COMMA = r"\,"
+    ns.t_PRODUCT = "[*.]"
+    ns.t_DIVISION = "/"
+    ns.t_POWER = r"\^|(\*\*)"
+    ns.t_OPEN_PAREN = r"\("
+    ns.t_CLOSE_PAREN = r"\)"
+
+    def t_UFLOAT(t):
+        r"((\d+\.?\d*)|(\.\d+))([eE][+-]?\d+)?"
+        if not re.search(r"[eE\.]", t.value):
+            t.type = "UINT"
+            t.value = int(t.value)
+        elif t.value.endswith("."):
+            t.type = "UINT"
+            t.value = int(t.value[:-1])
+        else:
+            t.value = float(t.value)
+        return t
+
+    def t_UINT(t):
+        r"\d+"
+        t.value = int(t.value)
+        return t
+
+    def t_SIGN(t):
+        r"[+-](?=\d)"
+        t.value = int(t.value + "1")
+        return t
+
+    def t_FUNCNAME(t):
+        r"((sqrt)|(ln)|(exp)|(log)|(mag)|(dB)|(dex))(?=\ *\()"
+        return t
+
+    def t_UNIT(t):
+        r"[^\s\d+\-\./\*\^\(\)\,]+"
+        t.value = cls._get_unit(t)
+        return t
+
+    ns.t_ignore = " "
+
+    def t_error(t):
+        raise ValueError(f"Invalid character at col {t.lexpos}")
+
+    ns.t_UFLOAT = t_UFLOAT
+    ns.t_UINT = t_UINT
+    ns.t_SIGN = t_SIGN
+    ns.t_FUNCNAME = t_FUNCNAME
+    ns.t_UNIT = t_UNIT
+    ns.t_error = t_error
+
+    def p_main(p):
+        """
+        main : unit
+             | structured_unit
+             | structured_subunit
+        """
+        if isinstance(p[1], tuple):
+            p[0] = p[1][0]
+        else:
+            p[0] = p[1]
+
+    def p_structured_subunit(p):
+        """
+        structured_subunit : OPEN_PAREN structured_unit CLOSE_PAREN
+        """
+        p[0] = (p[2],)
+
+    def p_structured_unit(p):
+        """
+        structured_unit : subunit COMMA
+                        | subunit COMMA subunit
+        """
+        from astropy.units.structured import StructuredUnit
+
+        inputs = (p[1],) if len(p) == 3 else (p[1], p[3])
+        units = ()
+        for subunit in inputs:
+            if isinstance(subunit, tuple):
+                units += subunit
+            elif isinstance(subunit, StructuredUnit):
+                units += subunit.values()
+            else:
+                units += (subunit,)
+
+        p[0] = StructuredUnit(units)
+
+    def p_subunit(p):
+        """
+        subunit : unit
+                | structured_unit
+                | structured_subunit
+        """
+        p[0] = p[1]
+
+    def p_unit(p):
+        """
+        unit : product_of_units
+             | factor product_of_units
+             | factor PRODUCT product_of_units
+             | division_product_of_units
+             | factor division_product_of_units
+             | factor PRODUCT division_product_of_units
+             | inverse_unit
+             | factor inverse_unit
+             | factor PRODUCT inverse_unit
+             | factor
+        """
+        if len(p) == 2:
+            p[0] = Unit(p[1])
+        elif len(p) == 3:
+            p[0] = CompositeUnit(p[1] * p[2].scale, p[2].bases, p[2].powers)
+        elif len(p) == 4:
+            p[0] = CompositeUnit(p[1] * p[3].scale, p[3].bases, p[3].powers)
+
+    def p_division_product_of_units(p):
+        """
+        division_product_of_units : division_product_of_units DIVISION product_of_units
+                                  | product_of_units
+        """
+        if len(p) == 4:
+            p[0] = Unit(p[1] / p[3])
+        else:
+            p[0] = p[1]
+
+    def p_inverse_unit(p):
+        """
+        inverse_unit : DIVISION unit_expression
+        """
+        p[0] = p[2] ** -1
+
+    def p_factor(p):
+        """
+        factor : factor_fits
+               | factor_float
+               | factor_int
+        """
+        p[0] = p[1]
+
+    def p_factor_float(p):
+        """
+        factor_float : signed_float
+                     | signed_float UINT signed_int
+                     | signed_float UINT POWER numeric_power
+        """
+        if cls.name == "fits":
+            raise ValueError("Numeric factor not supported by FITS")
+        if len(p) == 4:
+            p[0] = p[1] * p[2] ** float(p[3])
+        elif len(p) == 5:
+            p[0] = p[1] * p[2] ** float(p[4])
+        elif len(p) == 2:
+            p[0] = p[1]
+
+    def p_factor_int(p):
+        """
+        factor_int : UINT
+                   | UINT signed_int
+                   | UINT POWER numeric_power
+                   | UINT UINT signed_int
+                   | UINT UINT POWER numeric_power
+        """
+        if cls.name == "fits":
+            raise ValueError("Numeric factor not supported by FITS")
+        if len(p) == 2:
+            p[0] = p[1]
+        elif len(p) == 3:
+            p[0] = p[1] ** float(p[2])
+        elif len(p) == 4:
+            if isinstance(p[2], int):
+                p[0] = p[1] * p[2] ** float(p[3])
+            else:
+                p[0] = p[1] ** float(p[3])
+        elif len(p) == 5:
+            p[0] = p[1] * p[2] ** p[4]
+
+    def p_factor_fits(p):
+        """
+        factor_fits : UINT POWER OPEN_PAREN signed_int CLOSE_PAREN
+                    | UINT POWER OPEN_PAREN UINT CLOSE_PAREN
+                    | UINT POWER signed_int
+                    | UINT POWER UINT
+                    | UINT SIGN UINT
+                    | UINT OPEN_PAREN signed_int CLOSE_PAREN
+        """
+        if p[1] != 10:
+            if cls.name == "fits":
+                raise ValueError("Base must be 10")
+            else:
+                return
+        if len(p) == 4:
+            if p[2] in ("**", "^"):
+                p[0] = 10 ** p[3]
+            else:
+                p[0] = 10 ** (p[2] * p[3])
+        elif len(p) == 5:
+            p[0] = 10 ** p[3]
+        elif len(p) == 6:
+            p[0] = 10 ** p[4]
+
+    def p_product_of_units(p):
+        """
+        product_of_units : unit_expression PRODUCT product_of_units
+                         | unit_expression product_of_units
+                         | unit_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        elif len(p) == 3:
+            p[0] = p[1] * p[2]
+        else:
+            p[0] = p[1] * p[3]
+
+    def p_unit_expression(p):
+        """
+        unit_expression : function
+                        | unit_with_power
+                        | OPEN_PAREN product_of_units CLOSE_PAREN
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = p[2]
+
+    def p_unit_with_power(p):
+        """
+        unit_with_power : UNIT POWER numeric_power
+                        | UNIT numeric_power
+                        | UNIT
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        elif len(p) == 3:
+            p[0] = p[1] ** p[2]
+        else:
+            p[0] = p[1] ** p[3]
+
+    def p_numeric_power(p):
+        """
+        numeric_power : sign UINT
+                      | OPEN_PAREN paren_expr CLOSE_PAREN
+        """
+        if len(p) == 3:
+            p[0] = p[1] * p[2]
+        elif len(p) == 4:
+            p[0] = p[2]
+
+    def p_paren_expr(p):
+        """
+        paren_expr : sign UINT
+                   | signed_float
+                   | frac
+        """
+        if len(p) == 3:
+            p[0] = p[1] * p[2]
+        else:
+            p[0] = p[1]
+
+    def p_frac(p):
+        """
+        frac : sign UINT DIVISION sign UINT
+        """
+        p[0] = Fraction(p[1] * p[2], p[4] * p[5])
+
+    def p_sign(p):
+        """
+        sign : SIGN
+             |
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = 1
+
+    def p_signed_int(p):
+        """
+        signed_int : SIGN UINT
+        """
+        p[0] = p[1] * p[2]
+
+    def p_signed_float(p):
+        """
+        signed_float : sign UINT
+                     | sign UFLOAT
+        """
+        p[0] = p[1] * p[2]
+
+    def p_function(p):
+        """
+        function : FUNCNAME OPEN_PAREN main CLOSE_PAREN
+        """
+        if p[1] == "sqrt":
+            p[0] = p[3] ** 0.5
+            return
+        elif p[1] in ("mag", "dB", "dex"):
+            function_unit = cls._validate_unit(p[1])
+            if callable(function_unit):
+                p[0] = function_unit(p[3])
+                return
+
+        raise ValueError(f"'{p[1]}' is not a recognized function")
+
+    def p_error(p):
+        raise ValueError()
+
+    ns.p_main = p_main
+    ns.p_structured_subunit = p_structured_subunit
+    ns.p_structured_unit = p_structured_unit
+    ns.p_subunit = p_subunit
+    ns.p_unit = p_unit
+    ns.p_division_product_of_units = p_division_product_of_units
+    ns.p_inverse_unit = p_inverse_unit
+    ns.p_factor = p_factor
+    ns.p_factor_float = p_factor_float
+    ns.p_factor_int = p_factor_int
+    ns.p_factor_fits = p_factor_fits
+    ns.p_product_of_units = p_product_of_units
+    ns.p_unit_expression = p_unit_expression
+    ns.p_unit_with_power = p_unit_with_power
+    ns.p_numeric_power = p_numeric_power
+    ns.p_paren_expr = p_paren_expr
+    ns.p_frac = p_frac
+    ns.p_sign = p_sign
+    ns.p_signed_int = p_signed_int
+    ns.p_signed_float = p_signed_float
+    ns.p_function = p_function
+    ns.p_error = p_error
+
+    return ns
+
+
+def _namespace_pdict(ns: types.ModuleType) -> dict[str, Any]:
+    return {k: getattr(ns, k) for k in dir(ns)}
+
+
+def patch_generic_unit_parser() -> None:
+    """Patch astropy.extern.ply's frame-walking helpers to fall back to our vendored grammar.
+
+    Safe to call unconditionally (frozen or not) -- under a normal, unfrozen interpreter the
+    original frame walk always succeeds, so the fallback path never triggers.
+    """
+    from astropy.extern.ply import lex as ply_lex
+    from astropy.extern.ply import yacc as ply_yacc
+
+    original_yacc_dict = ply_yacc.get_caller_module_dict
+    original_lex_dict = ply_lex.get_caller_module_dict
+
+    def _fallback_pdict(pdict: dict[str, Any] | None) -> dict[str, Any]:
+        # Keep whatever the real (possibly broken-locals) pdict already has -- __file__/
+        # __package__/__name__ are module globals and come through fine even on a compiled
+        # frame -- and only supplement the missing tokens/p_*/t_* grammar entries. Replacing
+        # __file__ wholesale would point astropy's tab-file bookkeeping at the wrong directory.
+        if "ns" not in _generic_ns_cache:
+            _generic_ns_cache["ns"] = _build_generic_grammar_namespace()
+        merged = dict(pdict) if pdict else {}
+        merged.update(_namespace_pdict(_generic_ns_cache["ns"]))
+        return merged
+
+    def patched_yacc_dict(levels: int) -> dict[str, Any]:
+        try:
+            pdict = original_yacc_dict(levels)
+        except Exception:
+            return _fallback_pdict(None)
+        if "tokens" not in pdict:
+            return _fallback_pdict(pdict)
+        return pdict
+
+    def patched_lex_dict(levels: int) -> dict[str, Any]:
+        try:
+            pdict = original_lex_dict(levels)
+        except Exception:
+            return _fallback_pdict(None)
+        if "tokens" not in pdict:
+            return _fallback_pdict(pdict)
+        return pdict
+
+    ply_yacc.get_caller_module_dict = patched_yacc_dict
+    ply_lex.get_caller_module_dict = patched_lex_dict

pyobs_gui-2.0.0.dev6/pyobs_gui/accounts.py

@@ -0,0 +1,150 @@
+"""Saved XMPP login accounts, persisted via QSettings -- see specs/plans/gui-login-window.md.
+
+Each account has a stable internal id (a uuid4 hex string, generated in add_account()) distinct
+from its jid/label -- both are freely editable via update_account(), and the id (not jid/label) is
+what a stored password gets keyed on in the system keychain, so renaming an account never orphans
+its password. Mirrors pyobs-polaris's SavedAccountsModel, which follows the same rule for the same
+reason.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+
+from PySide6 import QtCore
+
+_ORGANIZATION = "pyobs"
+_APPLICATION = "pyobs-gui"
+
+
+@dataclass
+class Account:
+    id: str
+    jid: str
+    label: str = ""
+    host: str = ""
+    port: int = 0
+    use_tls: bool = True
+    insecure_skip_tls: bool = False
+
+    @property
+    def display_name(self) -> str:
+        return self.label if self.label else self.jid
+
+
+class SavedAccountsModel:
+    """Saved account list, persisted via QSettings. Password storage is a separate concern --
+    see login.py's use of the `keyring` package, keyed by Account.id."""
+
+    def __init__(self, settings: QtCore.QSettings | None = None) -> None:
+        self._settings = settings if settings is not None else QtCore.QSettings(_ORGANIZATION, _APPLICATION)
+
+    def list_accounts(self) -> list[Account]:
+        accounts = []
+        size = self._settings.beginReadArray("accounts")
+        try:
+            for i in range(size):
+                self._settings.setArrayIndex(i)
+                accounts.append(
+                    Account(
+                        id=str(self._settings.value("id", "")),
+                        jid=str(self._settings.value("jid", "")),
+                        label=str(self._settings.value("label", "")),
+                        host=str(self._settings.value("host", "")),
+                        port=int(self._settings.value("port", 0, type=int)),  # pyrefly: ignore [bad-argument-type]
+                        use_tls=bool(self._settings.value("use_tls", True, type=bool)),
+                        insecure_skip_tls=bool(self._settings.value("insecure_skip_tls", False, type=bool)),
+                    )
+                )
+        finally:
+            self._settings.endArray()
+        return accounts
+
+    def account_by_id(self, account_id: str) -> Account | None:
+        for account in self.list_accounts():
+            if account.id == account_id:
+                return account
+        return None
+
+    def add_account(
+        self,
+        jid: str,
+        label: str = "",
+        host: str = "",
+        port: int = 0,
+        use_tls: bool = True,
+        insecure_skip_tls: bool = False,
+    ) -> str:
+        """Adds a new account and returns its newly generated id."""
+        account = Account(
+            id=uuid.uuid4().hex,
+            jid=jid,
+            label=label,
+            host=host,
+            port=port,
+            use_tls=use_tls,
+            insecure_skip_tls=insecure_skip_tls,
+        )
+        accounts = self.list_accounts()
+        accounts.append(account)
+        self._write_all(accounts)
+        return account.id
+
+    def update_account(
+        self,
+        account_id: str,
+        jid: str,
+        label: str = "",
+        host: str = "",
+        port: int = 0,
+        use_tls: bool = True,
+        insecure_skip_tls: bool = False,
+    ) -> None:
+        """Updates an existing account's fields in place -- the id itself never changes."""
+        accounts = self.list_accounts()
+        for i, account in enumerate(accounts):
+            if account.id == account_id:
+                accounts[i] = Account(
+                    id=account_id,
+                    jid=jid,
+                    label=label,
+                    host=host,
+                    port=port,
+                    use_tls=use_tls,
+                    insecure_skip_tls=insecure_skip_tls,
+                )
+                break
+        self._write_all(accounts)
+
+    def remove_account(self, account_id: str) -> None:
+        accounts = [a for a in self.list_accounts() if a.id != account_id]
+        self._write_all(accounts)
+
+    def _write_all(self, accounts: list[Account]) -> None:
+        self._settings.beginWriteArray("accounts")
+        try:
+            for i, account in enumerate(accounts):
+                self._settings.setArrayIndex(i)
+                self._settings.setValue("id", account.id)
+                self._settings.setValue("jid", account.jid)
+                self._settings.setValue("label", account.label)
+                self._settings.setValue("host", account.host)
+                self._settings.setValue("port", account.port)
+                self._settings.setValue("use_tls", account.use_tls)
+                self._settings.setValue("insecure_skip_tls", account.insecure_skip_tls)
+        finally:
+            self._settings.endArray()
+
+    @property
+    def last_selected_account_id(self) -> str:
+        """Only remembers which account was last used (to preselect it next launch) -- never
+        implies anything was saved/connected automatically."""
+        return str(self._settings.value("last_selected_account_id", ""))
+
+    @last_selected_account_id.setter
+    def last_selected_account_id(self, value: str) -> None:
+        self._settings.setValue("last_selected_account_id", value)
+
+
+__all__ = ["Account", "SavedAccountsModel"]

{pyobs_gui-2.0.0.dev4 → pyobs_gui-2.0.0.dev6}/pyobs_gui/compassmovewidget.py

@@ -46,7 +46,9 @@ class CompassMoveWidget(BaseWidget, Ui_CompassMoveWidget):
             if altaz_state is None:
                 return
             altaz = SkyCoord(
+                # pyrefly: ignore [missing-attribute]
                 alt=altaz_state.alt * u.degree,
+                # pyrefly: ignore [missing-attribute]
                 az=altaz_state.az * u.degree,
                 obstime=Time.now(),
                 location=self.observer.location,