starbash 0.3.5__tar.gz → 0.3.7__tar.gz

{starbash-0.3.5 → starbash-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: starbash
-Version: 0.3.5
+Version: 0.3.7
 Summary: A tool for automating/standardizing/sharing astrophotography workflows.
 License-File: LICENSE
 Author: Kevin Hester

{starbash-0.3.5 → starbash-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "starbash"
-version = "0.3.5"
+version = "0.3.7"
 description = "A tool for automating/standardizing/sharing astrophotography workflows."
 authors = ["Kevin Hester <kevinh@geeksville.com>"]
 readme = "README.md"

{starbash-0.3.5 → starbash-0.3.7}/src/starbash/tool/rcastro.py

@@ -5,6 +5,7 @@ import json
 import logging
 import os
 import re
+import sys
 from typing import Any
 
 from starbash.tool.base import (
@@ -66,6 +67,8 @@ class RCAstroTool(ExternalTool):
             # plenty of workflows never use them.
             ToolSeverity.OPTIONAL,
         )
+        if sys.platform == "win32":
+            self.commands.append(r"C:\Program Files\RC-Astro\CLI\rc-astro.exe")
 
     def set_defaults(self) -> None:
         super().set_defaults()

{starbash-0.3.5 → starbash-0.3.7}/src/starbash/tool/starnet.py

@@ -66,8 +66,15 @@ class StarnetTool(SirilTool):
 
     @staticmethod
     def _siril_config_dir() -> Path:
-        """Location of the config directory of a natively installed Siril (OS-appropriate)."""
-        return Path(PlatformDirs("siril").user_config_dir)
+        """Location of the config directory of a natively installed Siril (OS-appropriate).
+
+        ``appauthor=False`` matters on Windows: platformdirs appends the app author
+        (which defaults to the app name) *and* the app name, so ``PlatformDirs("siril")``
+        would resolve to ``AppData\\Local\\siril\\siril``.  Siril keeps its config in
+        ``AppData\\Local\\siril`` (single level), so the author directory is dropped.
+        On Linux/macOS ``appauthor`` is ignored, so this is safe everywhere.
+        """
+        return Path(PlatformDirs("siril", appauthor=False).user_config_dir)
 
     @staticmethod
     def _siril_flatpak_config_dir() -> Path:
@@ -222,14 +229,58 @@ class StarnetTool(SirilTool):
                 self._starnet_available = True
         return self._starnet_available
 
+    def invalidate_availability(self) -> None:
+        """Forget the cached StarNet probe, so the next check re-probes.
+
+        This tool keeps its own cache (``_starnet_available``, plus
+        ``_starnet_dangling`` for a StarNet that has gone missing since the probe),
+        and ``is_available`` never reads ``ExternalTool._is_available``: the base
+        implementation would therefore clear Siril's cached answer while StarNet's
+        stayed behind.  The GUI setup wizard's *Re-check* button is the caller that
+        needs this - without the override it could never notice a StarNet installed
+        while the wizard was open.
+        """
+        self._starnet_available = None
+        # A stale path only describes the probe it was found in, so it goes with
+        # ``is_available``'s cached answer: a re-check that now succeeds must not
+        # keep reporting the last run's dead setting.
+        self._starnet_dangling = None
+        super().invalidate_availability()
+
     def missing_message(self) -> str:
-        """Explain which of the two StarNet prerequisites is missing."""
+        """Explain which of StarNet's prerequisites is missing.
+
+        Three cases need three different fixes, so they are checked in order: Siril
+        missing (nothing can run), StarNet missing (nothing to run), and StarNet
+        present but Siril not able to use it.  The install check is done here rather
+        than from the cached probe because "is StarNet installed *at all*" is
+        independent of what Siril's config says - a stale setting must not be
+        reported as an installed-but-misconfigured StarNet.
+        """
         if not super().is_available:
             # StarNet is a Siril plugin, so Siril has to come first.
             return (
                 f"StarNet is a Siril plugin, but Siril was not found.  Install Siril from "
                 f"{SIRIL_INSTALL_URL} and then StarNet from {self.install_url}"
             )
+        if _find_starnet_executable() is None:
+            # No StarNet anywhere we look, so there is nothing for Siril to be pointed
+            # at yet and installing it is the only fix.
+            if self._starnet_dangling:
+                # Siril *does* name a StarNet, that install is simply gone - so the
+                # stale path is what the user will trip over.  Say both: the download
+                # to make, and the setting that is waiting for something else.
+                return (
+                    f"StarNet is not installed. Siril is configured to use "
+                    f"{self._starnet_dangling}, but that file no longer exists - install "
+                    f"StarNet from {self.install_url} and then point Siril at it "
+                    f"(Preferences > Miscellaneous)"
+                )
+            return (
+                f"StarNet is not installed. Starbash could not find a starnet2 executable "
+                f"on your PATH or in StarNet's usual install location; download and "
+                f"install it from {self.install_url}"
+            )
         if self._starnet_dangling:
             return (
                 f"StarNet is configured in Siril as {self._starnet_dangling}, but that "

{starbash-0.3.5 → starbash-0.3.7}/src/starbash/ui/qt/pages/wizard.py

@@ -677,25 +677,45 @@ class ToolsPage(SetupPage):
 
     # --- probing ----------------------------------------------------------
     @staticmethod
-    def _recheck_required() -> list[ToolStatus]:
-        """Re-probe the required tools, then report which are still missing.
-
-        ``is_available`` caches its first answer, so a user who installs Siril
-        while this page is open would otherwise keep seeing "missing" forever.
+    def _reprobe_tools() -> list[ToolStatus]:
+        """Drop **every** tool's cached probe, then report which gating tools are missing.
+
+        ``is_available`` caches its first answer for the life of the process, so a
+        refresh that does not drop that cache keeps reporting whatever the first
+        probe saw - and this page exists to notice a tool the user installed while
+        the wizard was open.  All tools are re-probed, not just the ones that gate
+        the page: the cache is process-wide, and the main window's warning bar
+        re-reads it (`ToolWarningPanel.refresh()`) the moment the wizard closes, so a
+        StarNet installed during the wizard must not leave a stale bar behind.
+
+        Cheap enough for the GUI thread: every probe is a few filesystem lookups
+        (``shutil.which``/``Path.is_file``, plus StarNet reading Siril's config) and
+        no tool is ever executed to test it.
         """
         for tool in tools.values():
-            if tool.status().severity >= ToolSeverity.REQUIRED:
-                tool.invalidate_availability()
+            tool.invalidate_availability()
         return _required_tools_missing()
 
-    def _on_recheck(self) -> None:
-        """*Re-check* for one tool: forget the cached probe and repaint."""
-        missing = self._recheck_required()
+    def _on_recheck(self, key: str) -> None:
+        """*Re-check* one row's tool: forget its cached probe, re-probe, repaint.
+
+        Only the row's **own** tool is re-probed: re-checking used to invalidate just
+        the tools that gate the page, which left a *recommended* tool's row (StarNet
+        has a button too) reading a cached answer for ever.  ``_reprobe_tools()`` is
+        the wider path, taken when the page is left.
+        """
+        tool = tools.get(key)
+        if tool is not None:
+            tool.invalidate_availability()
+        # Read the status *now*, so the line below describes the re-probe rather
+        # than whatever refresh() saw before it.
+        status = next((s for s in tool_statuses() if s.key == key), None)
         self.refresh()
-        if missing:
-            self._status.setText(f"Still not found: {', '.join(t.name for t in missing)}")
-        else:
-            self._status.setText("Everything found — you can continue.")
+        if status is None:  # a key with no registered tool: the repaint says enough
+            return
+        self._status.setText(
+            f"Found {status.name}." if status.available else f"Still not found: {status.name}"
+        )
 
     def _on_install(self, url: str) -> None:
         """Open a tool's install page in the user's browser."""
@@ -727,7 +747,9 @@ class ToolsPage(SetupPage):
                 install.clicked.connect(lambda _checked=False, u=url: self._on_install(u))
                 line.addWidget(install)
             recheck = QPushButton("Re-check")
-            recheck.clicked.connect(lambda _checked=False: self._on_recheck())
+            # The row's own tool, not the page's gate: a *recommended* tool's row
+            # gets this button too, and only that tool's cache needs dropping.
+            recheck.clicked.connect(lambda _checked=False, k=status.key: self._on_recheck(k))
             line.addWidget(recheck)
 
         self._rows.addWidget(row)
@@ -760,8 +782,13 @@ class ToolsPage(SetupPage):
         return not _required_tools_missing()
 
     def validatePage(self) -> bool:  # noqa: N802 - Qt API
-        """Belt to :meth:`isComplete`'s braces, and the loud re-run failure."""
-        missing = self._recheck_required()
+        """Belt to :meth:`isComplete`'s braces, and the loud re-run failure.
+
+        Leaving the page re-probes *every* tool (see :meth:`_reprobe_tools`), which is
+        also what makes the main window's warning bar correct as soon as the wizard
+        closes: it re-reads the same cached answers.
+        """
+        missing = self._reprobe_tools()
         self.refresh()
         if not missing:
             return True