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

{starbash/repo → repo}/__init__.py

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

repo/manager.py

@@ -0,0 +1,144 @@
+"""
+Manages the repository of processing recipes and configurations.
+"""
+
+from __future__ import annotations
+import logging
+from pathlib import Path
+from importlib import resources
+from typing import Any
+
+import tomlkit
+from tomlkit.toml_file import TOMLFile
+from tomlkit.items import AoT
+from multidict import MultiDict
+from repo.repo import Repo
+
+
+class RepoManager:
+    """
+    Manages the collection of starbash repositories.
+
+    This class is responsible for finding, loading, and providing an API
+    for searching through known repositories defined in TOML configuration
+    files (like appdefaults.sb.toml).
+    """
+
+    def __init__(self):
+        """
+        Initializes the RepoManager by loading the application default repos.
+        """
+        self.repos = []
+
+        # 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)
+        # self.repos.append(root_repo)
+
+        # Most users will just want to read from merged
+        self.merged = MultiDict()
+
+    @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")
+        ]
+
+    def add_repo(self, url: str) -> Repo:
+        logging.debug(f"Adding repo: {url}")
+        r = Repo(self, url)
+        self.repos.append(r)
+
+        # FIXME, generate the merged dict lazily
+        self._add_merged(r)
+
+        # if this new repo has sub-repos, add them too
+        r.add_by_repo_refs()
+
+        return r
+
+    def get_repo_by_url(self, url: str) -> Repo | None:
+        """
+        Retrieves a repository by its URL.
+
+        Args:
+            url: The URL of the repository to retrieve.
+
+        Returns:
+            The Repo instance with the matching URL, or None if not found.
+        """
+        for repo in self.repos:
+            if repo.url == url:
+                return repo
+        return None
+
+    def get_repo_by_kind(self, kind: str) -> Repo | None:
+        """
+        Retrieves the first repository matching the specified kind.
+
+        Args:
+            kind: The kind of repository to search for (e.g., "recipe", "preferences").
+
+        Returns:
+            The first Repo instance matching the kind, or None if not found.
+        """
+        for repo in self.repos:
+            if repo.kind() == kind:
+                return repo
+        return None
+
+    def get(self, key: str, default=None):
+        """
+        Searches for a key across all repositories and returns the first value found.
+        The search is performed in reverse order of repository loading, so the
+        most recently added repositories have precedence.
+
+        Args:
+            key: The dot-separated key to search for (e.g., "repo.kind").
+            default: The value to return if the key is not found in any repo.
+
+        Returns:
+            The found value or the default.
+        """
+        # Iterate in reverse to give precedence to later-loaded repos
+        for repo in reversed(self.repos):
+            value = repo.get(key)
+            if value is not None:
+                return value
+
+        return default
+
+    def dump(self):
+        """
+        Prints a detailed, multi-line description of the combined top-level keys
+        and values from all repositories, using a MultiDict for aggregation.
+        This is useful for debugging and inspecting the consolidated configuration.
+        """
+
+        combined_config = self.merged
+        logging.info("RepoManager Dump")
+        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)
+
+    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):
+        lines = [f"RepoManager with {len(self.repos)} repositories:"]
+        for i, repo in enumerate(self.repos):
+            lines.append(f"  [{i}] {repo.url}")
+        return "\n".join(lines)

starbash/repo/manager.py → repo/repo.py

@@ -1,18 +1,16 @@
-"""
-Manages the repository of processing recipes and configurations.
-"""
-
 from __future__ import annotations
 import logging
 from pathlib import Path
 from importlib import resources
-from typing import Any
+from typing import Any, TYPE_CHECKING
 
 import tomlkit
 from tomlkit.toml_file import TOMLFile
 from tomlkit.items import AoT
 from multidict import MultiDict
 
+if TYPE_CHECKING:
+    from repo.manager import RepoManager
 
 repo_suffix = "starbash.toml"
 
@@ -39,7 +37,7 @@ class Repo:
 
         Example: "Repo(kind=recipe, local=True, url=file:///path/to/repo)"
         """
-        return f"Repo(kind={self.kind}, url={self.url})"
+        return f"Repo(kind={self.kind()}, url={self.url})"
 
     __repr__ = __str__
 
@@ -53,14 +51,14 @@ class Repo:
         c = self.get("repo.kind", unknown_kind)
         return str(c)
 
-    def add_repo_ref(self, dir: str) -> Repo | None:
+    def add_repo_ref(self, dir: Path) -> Repo | None:
         """
         Adds a new repo-ref to this repository's configuration.
         if new returns the newly added Repo object, if already exists returns None"""
 
         # if dir is not absolute, we need to resolve it relative to the cwd
-        if not Path(dir).is_absolute():
-            dir = str((Path.cwd() / dir).resolve())
+        if not dir.is_absolute():
+            dir = (Path.cwd() / dir).resolve()
 
         # Add the ref to this repo
         aot = self.config.get(REPO_REF, None)
@@ -72,11 +70,11 @@ class Repo:
             raise ValueError(f"repo-ref in {self.url} is not an array")
 
         for t in aot:
-            if "dir" in t and t["dir"] == dir:
+            if "dir" in t and t["dir"] == str(dir):
                 logging.warning(f"Repo ref {dir} already exists - ignoring.")
                 return None  # already exists
 
-        ref = {"dir": dir}
+        ref = {"dir": str(dir)}
         aot.append(ref)
 
         # Also add the repo to the manager
@@ -156,22 +154,22 @@ class Repo:
         for ref in repo_refs:
             self.add_from_ref(ref)
 
-    def _read_file(self, filepath: str) -> str:
+    def resolve_path(self, filepath: str) -> Path:
         """
-        Read a filepath relative to the base of this repo. Return the contents in a string.
+        Resolve a filepath relative to the base of this repo.
 
         Args:
             filepath: The path to the file, relative to the repository root.
 
         Returns:
-            The content of the file as a string.
+            The resolved Path object.
         """
         base_path = self.get_path()
         if base_path is None:
-            raise ValueError("Cannot read files from non-local repositories")
+            raise ValueError("Cannot resolve filepaths for non-local repositories")
         target_path = (base_path / filepath).resolve()
 
-        # Security check to prevent reading files outside the repo directory.
+        # Security check to prevent accessing files outside the repo directory.
         # FIXME SECURITY - temporarily disabled because I want to let file urls say things like ~/foo.
         # it would false trigger if user homedir path has a symlink in it (such as /home -> /var/home)
         #   base_path = PosixPath('/home/kevinh/.config/starbash')                   │                                                                                          │
@@ -180,7 +178,21 @@ class Repo:
         #   target_path = PosixPath('/var/home/kevinh/.config/starbash/starbash.toml')
         #
         # if base_path not in target_path.parents and target_path != base_path:
-        #    raise PermissionError("Attempted to read file outside of repository")
+        #    raise PermissionError("Attempted to access file outside of repository")
+
+        return target_path
+
+    def _read_file(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.
+        """
+        target_path = self.resolve_path(filepath)
 
         return target_path.read_text()
 
@@ -280,102 +292,3 @@ class Repo:
 
         # Set the final value
         current[keys[-1]] = value
-
-
-class RepoManager:
-    """
-    Manages the collection of starbash repositories.
-
-    This class is responsible for finding, loading, and providing an API
-    for searching through known repositories defined in TOML configuration
-    files (like appdefaults.sb.toml).
-    """
-
-    def __init__(self):
-        """
-        Initializes the RepoManager by loading the application default repos.
-        """
-        self.repos = []
-
-        # 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)
-        # self.repos.append(root_repo)
-
-        # Most users will just want to read from merged
-        self.merged = MultiDict()
-
-    @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")
-        ]
-
-    def add_repo(self, url: str) -> Repo:
-        logging.debug(f"Adding repo: {url}")
-        r = Repo(self, url)
-        self.repos.append(r)
-
-        # FIXME, generate the merged dict lazily
-        self._add_merged(r)
-
-        # if this new repo has sub-repos, add them too
-        r.add_by_repo_refs()
-
-        return r
-
-    def get(self, key: str, default=None):
-        """
-        Searches for a key across all repositories and returns the first value found.
-        The search is performed in reverse order of repository loading, so the
-        most recently added repositories have precedence.
-
-        Args:
-            key: The dot-separated key to search for (e.g., "repo.kind").
-            default: The value to return if the key is not found in any repo.
-
-        Returns:
-            The found value or the default.
-        """
-        # Iterate in reverse to give precedence to later-loaded repos
-        for repo in reversed(self.repos):
-            value = repo.get(key)
-            if value is not None:
-                return value
-
-        return default
-
-    def dump(self):
-        """
-        Prints a detailed, multi-line description of the combined top-level keys
-        and values from all repositories, using a MultiDict for aggregation.
-        This is useful for debugging and inspecting the consolidated configuration.
-        """
-
-        combined_config = self.merged
-        logging.info("RepoManager Dump")
-        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)
-
-    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):
-        lines = [f"RepoManager with {len(self.repos)} repositories:"]
-        for i, repo in enumerate(self.repos):
-            lines.append(f"  [{i}] {repo.url}")
-        return "\n".join(lines)

starbash/__init__.py

@@ -1,11 +1,38 @@
+import datetime
 import logging
+import os
+from datetime import datetime
 
 from .database import Database  # re-export for convenience
 from rich.console import Console
 
-console = 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
+console = Console(
+    force_terminal=False if _is_test_env else None,
+    width=999999 if _is_test_env else None,  # Disable line wrapping in tests
+)
 
 # Global variable for log filter level (can be changed via --debug flag)
 log_filter_level = logging.INFO
 
+
+def to_shortdate(date_iso: str) -> str:
+    """Convert ISO UTC datetime string to local short date string (YYYY-MM-DD).
+
+    Args:
+        date_iso: ISO format datetime string (e.g., "2023-10-15T14:30:00Z")
+
+    Returns:
+        Short date string in YYYY-MM-DD format
+    """
+    try:
+        dt_utc = datetime.fromisoformat(date_iso)
+        dt_local = dt_utc.astimezone()
+        return dt_local.strftime("%Y-%m-%d")
+    except (ValueError, TypeError):
+        return date_iso
+
+
 __all__ = ["Database"]

starbash/analytics.py

@@ -2,8 +2,9 @@ import logging
 import os
 
 import starbash
-from starbash import console
+from starbash import console, _is_test_env
 import starbash.url as url
+from sentry_sdk.integrations.excepthook import ExcepthookIntegration
 
 # Default to no analytics/auto crash reports
 analytics_allowed = False
@@ -25,6 +26,9 @@ def analytics_setup(allowed: bool = False, user_email: str | None = None) -> Non
             send_default_pii=True,
             enable_logs=True,
             traces_sample_rate=1.0,
+            disabled_integrations=[
+                ExcepthookIntegration()
+            ],  # This line removes the aggressive unhandled exception catcher
             integrations=[
                 LoggingIntegration(
                     level=starbash.log_filter_level,  # Capture INFO and above as breadcrumbs
@@ -51,11 +55,6 @@ def analytics_shutdown() -> None:
         sentry_sdk.flush()
 
 
-def is_running_in_pytest() -> bool:
-    """Detect if code is being run inside pytest."""
-    return "PYTEST_CURRENT_TEST" in os.environ
-
-
 def is_development_environment() -> bool:
     """Detect if running in a development environment."""
 
@@ -80,7 +79,7 @@ def analytics_exception(exc: Exception) -> bool:
     if analytics_allowed:
         import sentry_sdk
 
-        if is_running_in_pytest():
+        if _is_test_env:
             report_id = "TESTING-ENVIRONMENT"
         else:
             report_id = sentry_sdk.capture_exception(exc)