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

{pyobs_gui-2.0.0.dev5 → 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.dev5 → pyobs_gui-2.0.0.dev6}/.gitignore

@@ -6,3 +6,8 @@ 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.dev5 → pyobs_gui-2.0.0.dev6}/PKG-INFO

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

{pyobs_gui-2.0.0.dev5 → 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.dev5 → pyobs_gui-2.0.0.dev6}/pyobs_gui/__main__.py

@@ -6,13 +6,13 @@ unless the user opts into "store password" in the login window.
 
 from __future__ import annotations
 
-from pyobs.application import Application
 
-from .gui import GUI
-from .login import login_and_build_gui
+def main() -> None:
+    from pyobs.application import Application
 
+    from .gui import GUI
+    from .login import login_and_build_gui
 
-def main() -> None:
     app = Application(module_factory=login_and_build_gui, loop_module_class=GUI)
     app.run()
 

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.dev5 → pyobs_gui-2.0.0.dev6}/pyobs_gui/mainwindow.py

@@ -288,7 +288,7 @@ class MainWindow(QtWidgets.QMainWindow, BaseWindow, Ui_MainWindow):  # type: ign
         self._modules_header_added = False
 
         # navbar keyboard shortcuts: slot -> currently bound page name, session-only (see
-        # DEV_NavbarShortcuts.md)
+        # pyobs-core/specs/plans/gui-navbar-shortcuts.md)
         self._slot_bindings: Dict[str, str] = {}
         self.listPages.setItemDelegate(NavPageItemDelegate(self._slot_bindings, self))
         self._setup_shortcuts()
@@ -469,8 +469,8 @@ class MainWindow(QtWidgets.QMainWindow, BaseWindow, Ui_MainWindow):  # type: ign
         self._widgets / self._slot_bindings at press-time, since module pages come and go but the
         shortcut objects themselves live for the app's lifetime. Every shortcut requires Ctrl (or
         Ctrl+Alt) so no text/numeric-entry widget can ever mistake one for ordinary input -- see
-        DEV_NavbarShortcuts.md for why that's a structural guarantee rather than one that needs
-        per-widget-type verification.
+        pyobs-core/specs/plans/gui-navbar-shortcuts.md for why that's a structural guarantee
+        rather than one that needs per-widget-type verification.
         """
         self._shortcuts: List[QtGui.QShortcut] = []
 

{pyobs_gui-2.0.0.dev5 → pyobs_gui-2.0.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-gui"
-version = "2.0.0.dev5"
+version = "2.0.0.dev6"
 description = "A remote GUI for pyobs"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11,<3.14"
@@ -20,6 +20,9 @@ dependencies = [
     "secretstorage>=3.5.0,<4",
 ]
 
+[project.scripts]
+pyobs-gui = "pyobs_gui.__main__:main"
+
 [dependency-groups]
 dev = [
     "black>=25.1.0,<27",

pyobs_gui-2.0.0.dev6/pysidedeploy.spec

@@ -0,0 +1,97 @@
+[app]
+
+# title of your application
+title = pyobs-gui
+
+# project root directory. default = The parent directory of input_file
+project_dir = .
+
+# source file entry point path. default = main.py
+input_file = pyobs_gui
+
+# directory where the executable output is generated
+exec_directory = dist
+
+# path to the project file relative to project_dir
+project_file = 
+
+# application icon
+icon = /home/husser/code/pyobs/pyobs-gui/.venv/lib/python3.13/site-packages/PySide6/scripts/deploy_lib/pyside_icon.jpg
+
+[python]
+
+# python path
+python_path = /home/husser/code/pyobs/pyobs-gui/.venv/bin/python3
+
+# python packages to install
+packages = Nuitka==4.0
+
+# buildozer = for deploying Android application
+android_packages = buildozer==1.5.0,cython==0.29.33
+
+[qt]
+
+# paths to required qml files. comma separated
+# normally all the qml files required by the project are added automatically
+# design studio projects include the qml files using qt resources
+qml_files = 
+
+# excluded qml plugin binaries
+excluded_qml_plugins = 
+
+# qt modules used. comma separated
+modules = Core,DBus,Designer,Gui,Network,OpenGL,OpenGLWidgets,Widgets,Xml
+
+# qt plugins used by the application. only relevant for desktop deployment
+# for qt plugins used in android application see [android][plugins]
+plugins = accessiblebridge,designer,egldeviceintegrations,generic,iconengines,imageformats,networkaccess,networkinformation,platforminputcontexts,platforms,platforms/darwin,platformthemes,styles,tls,wayland-decoration-client,wayland-graphics-integration-client,wayland-shell-integration,xcbglintegrations
+
+[android]
+
+# path to pyside wheel
+wheel_pyside = 
+
+# path to shiboken wheel
+wheel_shiboken = 
+
+# plugins to be copied to libs folder of the packaged application. comma separated
+plugins = 
+
+[nuitka]
+
+# usage description for permissions requested by the app as found in the info.plist file
+# of the app bundle. comma separated
+# eg = extra_args = --show-modules --follow-stdlib
+macos.permissions = 
+
+# mode of using nuitka. accepts standalone or onefile. default = onefile
+mode = standalone
+
+# specify any extra nuitka arguments
+extra_args = --quiet --noinclude-qt-translations --clang --python-flag=-m --include-package=astropy.units.format --include-package=astropy.units.format.generic_parsetab --include-package=astropy.units.format.generic_lextab --include-package=astropy.units.format.cds_parsetab --include-package=astropy.units.format.cds_lextab --include-package=astropy.units.format.ogip_parsetab --include-package=astropy.units.format.ogip_lextab --include-package=astropy.coordinates.angles --include-package=astropy.coordinates.angles.angle_parsetab --include-package=astropy.coordinates.angles.angle_lextab --include-package=astropy.extern.ply --include-package-data=asdf --include-package-data=astropy --include-package-data=sunpy --include-package-data=matplotlib --include-package-data=qfitswidget --include-package-data=astropy_iers_data --include-package=pyobs.vfs --include-package-data=astroquery --include-package=slixmpp --noinclude-dlls=*webengine* --noinclude-dlls=*WebEngine* --include-distribution-metadata=astropy --include-distribution-metadata=numpy --include-distribution-metadata=scipy --include-distribution-metadata=PyYAML --include-distribution-metadata=sunpy --include-distribution-metadata=matplotlib --include-distribution-metadata=qfitswidget --include-distribution-metadata=astroquery --include-distribution-metadata=asdf --include-distribution-metadata=pyobs-core --include-distribution-metadata=pyobs-gui
+
+[buildozer]
+
+# build mode
+# possible values = ["aarch64", "armv7a", "i686", "x86_64"]
+# release creates a .aab, while debug creates a .apk
+mode = debug
+
+# path to pyside6 and shiboken6 recipe dir
+recipe_dir = 
+
+# path to extra qt android .jar files to be loaded by the application
+jars_dir = 
+
+# if empty, uses default ndk path downloaded by buildozer
+ndk_path = 
+
+# if empty, uses default sdk path downloaded by buildozer
+sdk_path = 
+
+# other libraries to be loaded at app startup. comma separated.
+local_libs = 
+
+# architecture of deployed platform
+arch = 
+

{pyobs_gui-2.0.0.dev5 → pyobs_gui-2.0.0.dev6}/specs/README.md

@@ -18,3 +18,17 @@ Relevant so far:
 - `pyobs-core/specs/plans/pyobs_2_0_work_plan.md` — the `IRunning.is_running()` removal item
   required updating `mainwindow.py`'s two RPC calls to that method to read `IRunning`'s pushed
   state instead.
+- `pyobs-core/specs/plans/gui-navbar-shortcuts.md` — implemented, closed. Control-group-style
+  keyboard shortcuts for the module sidebar.
+- `pyobs-core/specs/plans/gui-acl-aware-widget-gating.md` — implemented, closed. Greying out /
+  hiding actions an operator isn't permitted to use, per pyobs-core 2.0 ACLs.
+- `pyobs-core/specs/plans/gui-telescopewidget-layout.md` — proposed/exploratory.
+  `TelescopeWidget`'s minimum-width investigation and candidate fixes.
+- `pyobs-core/specs/adrs/0010-pyobs-gui-stays-on-qtwidgets-not-qml.md` — accepted. Whether
+  `pyobs-gui` should move to Qt Quick/QML; decided to stay on QtWidgets.
+- `pyobs-core/specs/plans/gui-iacquisition-widget.md` — implemented, closed. The `IAcquisition`
+  widget.
+- `pyobs-core/specs/plans/gui-iautofocus-widget.md` — proposed, not implemented yet. The
+  `IAutoFocus` widget.
+- `pyobs-core/specs/plans/gui-iautoguiding-widget.md` — in progress. The `IAutoGuiding` widget;
+  first pass shipped, follow-up refinement (physical-unit offsets) in progress.

{pyobs_gui-2.0.0.dev5 → pyobs_gui-2.0.0.dev6}/uv.lock

@@ -2375,7 +2375,7 @@ wheels = [
 
 [[package]]
 name = "pyobs-gui"
-version = "2.0.0.dev5"
+version = "2.0.0.dev6"
 source = { editable = "." }
 dependencies = [
     { name = "astroplan" },