starbash 0.1.9__py3-none-any.whl → 0.1.15__py3-none-any.whl

repo/__init__.py

@@ -3,6 +3,6 @@ The repo package handles finding, loading and searching starbash repositories.
 """
 
 from .manager import RepoManager
-from .repo import Repo, repo_suffix, REPO_REF
+from .repo import REPO_REF, Repo, repo_suffix
 
 __all__ = ["RepoManager", "Repo", "repo_suffix", "REPO_REF"]

repo/manager.py

@@ -2,17 +2,19 @@
 Manages the repository of processing recipes and configurations.
 """
 
+# pyright: reportImportCycles=false
+# The circular dependency between manager.py and repo.py is properly handled
+# using TYPE_CHECKING and local imports where needed.
+
 from __future__ import annotations
+
 import logging
-from pathlib import Path
-from importlib import resources
-from typing import Any
+from typing import TYPE_CHECKING
 
-import tomlkit
-from tomlkit.toml_file import TOMLFile
-from tomlkit.items import AoT
 from multidict import MultiDict
-from repo.repo import Repo
+
+if TYPE_CHECKING:
+    from repo.repo import Repo
 
 
 class RepoManager:
@@ -28,7 +30,7 @@ class RepoManager:
         """
         Initializes the RepoManager by loading the application default repos.
         """
-        self.repos = []
+        self.repos: list[Repo] = []
 
         # We expose the app default preferences as a special root repo with a private URL
         # root_repo = Repo(self, "pkg://starbash-defaults", config=app_defaults)
@@ -40,13 +42,11 @@ class RepoManager:
     @property
     def regular_repos(self) -> list[Repo]:
         "We exclude certain repo types (preferences, recipe) from the list of repos users care about."
-        return [
-            r
-            for r in self.repos
-            if r.kind() not in ("preferences") and not r.is_scheme("pkg")
-        ]
+        return [r for r in self.repos if r.kind() not in ("preferences") and not r.is_scheme("pkg")]
 
     def add_repo(self, url: str) -> Repo:
+        from repo.repo import Repo  # Local import to avoid circular dependency
+
         logging.debug(f"Adding repo: {url}")
         r = Repo(self, url)
         self.repos.append(r)
@@ -122,19 +122,10 @@ class RepoManager:
         for key, value in combined_config.items():
             # tomlkit.items() can return complex types (e.g., ArrayOfTables, Table)
             # For a debug dump, a simple string representation is usually sufficient.
-            logging.info(f"  %s: %s", key, value)
+            logging.info("  %s: %s", key, value)
 
     def _add_merged(self, repo: Repo) -> None:
         for key, value in repo.config.items():
-            # if the toml object is an AoT type, monkey patch each element in the array instead
-            if isinstance(value, AoT):
-                for v in value:
-                    setattr(v, "source", repo)
-                else:
-                    # We monkey patch source into any object that came from a repo, so that users can
-                    # find the source repo (for attribution, URL relative resolution, whatever...)
-                    setattr(value, "source", repo)
-
             self.merged.add(key, value)
 
     def __str__(self):

repo/repo.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
+
 import logging
-from pathlib import Path
 from importlib import resources
-from typing import Any, TYPE_CHECKING
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
 
 import tomlkit
-from tomlkit.toml_file import TOMLFile
 from tomlkit.items import AoT
-from multidict import MultiDict
+from tomlkit.toml_file import TOMLFile
 
 if TYPE_CHECKING:
     from repo.manager import RepoManager
@@ -31,6 +31,36 @@ class Repo:
         self.manager = manager
         self.url = url
         self.config = self._load_config()
+        self._monkey_patch()
+
+    def _monkey_patch(self, o: Any | None = None) -> None:
+        """Add a 'source' back-ptr to all child items in the config.
+
+        so that users can find the source repo (for attribution, URL relative resolution, whatever...)
+        """
+        # base case - start us recursing
+        if o is None:
+            self._monkey_patch(self.config)
+            return
+
+        # We monkey patch source into any object that came from a repo,
+        try:
+            o.source = self
+
+            # Recursively patch dict-like objects
+            if isinstance(o, dict):
+                for value in o.values():
+                    self._monkey_patch(value)
+            # Recursively patch list-like objects (including AoT)
+            elif hasattr(o, "__iter__") and not isinstance(o, str | bytes):
+                try:
+                    for item in o:
+                        self._monkey_patch(item)
+                except TypeError:
+                    # Not actually iterable, skip
+                    pass
+        except AttributeError:
+            pass  # simple types like int, str, float, etc. can't have attributes set on them
 
     def __str__(self) -> str:
         """Return a concise one-line description of this repo.
@@ -230,12 +260,7 @@ class Repo:
             A dictionary containing the parsed configuration.
         """
         try:
-            if self.is_scheme("file"):
-                config_content = self._read_file(repo_suffix)
-            elif self.is_scheme("pkg"):
-                config_content = self._read_resource(repo_suffix)
-            else:
-                raise ValueError(f"Unsupported URL scheme for repo: {self.url}")
+            config_content = self.read(repo_suffix)
             logging.debug(f"Loading repo config from {repo_suffix}")
             return tomlkit.parse(config_content)
         except FileNotFoundError:
@@ -244,6 +269,23 @@ class Repo:
             )  # we currently make it optional to have the config file at root
             return tomlkit.TOMLDocument()  # empty placeholder
 
+    def read(self, filepath: str) -> str:
+        """
+        Read a filepath relative to the base of this repo. Return the contents in a string.
+
+        Args:
+            filepath: The path to the file, relative to the repository root.
+
+        Returns:
+            The content of the file as a string.
+        """
+        if self.is_scheme("file"):
+            return self._read_file(filepath)
+        elif self.is_scheme("pkg"):
+            return self._read_resource(filepath)
+        else:
+            raise ValueError(f"Unsupported URL scheme for repo: {self.url}")
+
     def get(self, key: str, default: Any | None = None) -> Any | None:
         """
         Gets a value from this repo's config for a given key.

starbash/__init__.py

@@ -1,14 +1,15 @@
-import datetime
 import logging
 import os
 from datetime import datetime
 
-from .database import Database  # re-export for convenience
 from rich.console import Console
 
 # Disable Rich formatting in test environments (pytest or NO_COLOR set)
 # This prevents ANSI escape codes and line wrapping in test output for more reliable test parsing.
 _is_test_env = "PYTEST_VERSION" in os.environ
+
+# Note: this console instance is probably never used - because the Starbash constructor slams in a new version into
+# this global.
 console = Console(
     force_terminal=False if _is_test_env else None,
     width=999999 if _is_test_env else None,  # Disable line wrapping in tests
@@ -17,6 +18,12 @@ console = Console(
 # Global variable for log filter level (can be changed via --debug flag)
 log_filter_level = logging.INFO
 
+# Global variable for forcing some file generation
+force_regen = False
+
+# Show extra command output
+verbose_output = False
+
 
 def to_shortdate(date_iso: str) -> str:
     """Convert ISO UTC datetime string to local short date string (YYYY-MM-DD).
@@ -35,4 +42,4 @@ def to_shortdate(date_iso: str) -> str:
         return date_iso
 
 
-__all__ = ["Database"]
+__all__ = ["console", "to_shortdate", "log_filter_level", "force_regen", "verbose_output"]

starbash/aliases.py

@@ -0,0 +1,145 @@
+import logging
+import string
+from textwrap import dedent
+from typing import overload
+
+from starbash.exception import UserHandledError
+
+_translator = str.maketrans("", "", string.punctuation + string.whitespace)
+
+__all__ = [
+    "Aliases",
+    "UnrecognizedAliasError",
+    "normalize_target_name",
+    "pre_normalize",
+]
+
+
+@overload
+def normalize_target_name(name: str) -> str: ...
+
+
+@overload
+def normalize_target_name(name: None) -> None: ...
+
+
+def normalize_target_name(name: str | None) -> str | None:
+    """Converts a target name to an any filesystem-safe format by removing spaces"""
+    if name is None:
+        return None
+    return name.replace(" ", "").lower()
+
+
+def pre_normalize(name: str) -> str:
+    """Pre-normalize a name by removing all whitespace and punctuation, and converting to lowercase.
+
+    Args:
+        name: The name to pre-normalize.
+
+    Returns:
+        Normalized string with only alphanumeric characters in lowercase.
+    """
+    # Create translation table that removes all punctuation and whitespace
+    return name.lower().translate(_translator)
+
+
+class UnrecognizedAliasError(UserHandledError):
+    """Exception raised when an unrecognized alias is encountered during normalization."""
+
+    def __init__(self, message: str, alias: str):
+        super().__init__(message)
+        self.alias = alias
+
+    def ask_user_handled(self) -> bool:
+        from starbash import console  # Lazy import to avoid circular dependency
+        from starbash.paths import (
+            get_user_config_path,
+        )  # Moved to paths module to avoid circular dependency
+
+        console.print(
+            dedent(
+                f"""{self.__rich__()}
+
+                    For the time being that means editing {get_user_config_path() / "starbash.toml"}
+                    (FIXME - we'll eventually provide an interactive picker here...)
+                    """
+            )
+        )
+        return True
+
+    def __rich__(self) -> str:
+        return f"[red]Error:[/red] To process this session you need to add a missing alias for '[red]{self.alias}[/red]'."
+
+
+class Aliases:
+    def __init__(self, alias_dict: dict[str, list[str]]):
+        """Initialize the Aliases object with a dictionary mapping keys to their alias lists.
+
+        The alias_dict structure follows the TOML format:
+        - Keys are reference names used in code (e.g., "dark", "flat", "bias", "fits", "SiiOiii", "HaOiii")
+        - Values are lists of aliases where the FIRST item is the canonical/preferred name
+        - The dictionary key may or may not match the canonical name
+
+        Example from TOML:
+            [aliases]
+            dark = ["dark", "darks"]           # key "dark" -> canonical "dark"
+            flat = ["flat", "flats"]           # key "flat" -> canonical "flat"
+            SiiOiii = ["SiiOiii", "SII-OIII", "S2-O3"]  # key "SiiOiii" -> canonical "SiiOiii"
+        """
+        self.alias_dict = alias_dict
+        self.reverse_dict = {}
+
+        # Build reverse lookup: any alias variant maps to canonical name
+        for _key, aliases in alias_dict.items():
+            if not aliases:
+                continue
+            # The first item in the list is ALWAYS the canonical/preferred form
+            canonical = aliases[0]
+            for alias in aliases:
+                # Map each alias (case-insensitive) to the canonical form (first in list)
+                # Also remove spaces, hypens and underscores when matching for normalization
+                self.reverse_dict[pre_normalize(alias)] = canonical
+
+    def get(self, name: str) -> list[str] | None:
+        """Get the list of aliases for a given key name.
+
+        Args:
+            name: The key name to look up (as used in code/TOML)
+
+        Returns:
+            List of all aliases for this key, or None if not found.
+            The first item in the returned list is the canonical form.
+        """
+        return self.alias_dict.get(name)
+
+    def normalize(self, name: str, lenient: bool = False) -> str:
+        """Normalize a name to its canonical form using aliases.
+
+        This performs case-insensitive matching to find the canonical form.
+        The canonical form is the first item in the alias list from the TOML.
+
+        Args:
+            name: The name to normalize (e.g., "darks", "FLAT", "HA-OIII")
+            lenient: If True, return unconverted names if not found
+
+        Returns:
+            The canonical/preferred form (e.g., "dark", "flat", "HaOiii"), or None if not found
+
+        Examples:
+            normalize("darks") -> "dark"
+            normalize("FLAT") -> "flat"
+            normalize("HA-OIII") -> "HaOiii"
+        """
+        result = self.reverse_dict.get(pre_normalize(name))
+        if not result:
+            if lenient:
+                logging.warning(f"Unrecognized alias '{name}' encountered, using unconverted.")
+                return name
+            raise UnrecognizedAliasError(f"'{name}' not found in aliases.", name)
+        return result
+
+    def equals(self, name1: str, name2: str) -> bool:
+        """Check if two names are equivalent based on aliases."""
+        norm1 = self.normalize(name1.strip())
+        norm2 = self.normalize(name2.strip())
+        return norm1 == norm2

starbash/analytics.py

@@ -1,10 +1,11 @@
 import logging
 import os
 
+from sentry_sdk.integrations.excepthook import ExcepthookIntegration
+
 import starbash
-from starbash import console, _is_test_env
 import starbash.url as url
-from sentry_sdk.integrations.excepthook import ExcepthookIntegration
+from starbash import _is_test_env
 
 # Default to no analytics/auto crash reports
 analytics_allowed = False