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

starbash/__init__.py

@@ -1,9 +1,16 @@
 import logging
+import os
 
 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

starbash/analytics.py

@@ -2,7 +2,7 @@ import logging
 import os
 
 import starbash
-from starbash import console
+from starbash import console, _is_test_env
 import starbash.url as url
 
 # Default to no analytics/auto crash reports
@@ -51,11 +51,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 +75,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)

starbash/app.py

@@ -13,11 +13,11 @@ from rich.logging import RichHandler
 import shutil
 
 import starbash
-from starbash import console
+from starbash import console, _is_test_env
 from starbash.database import Database
-from starbash.repo.manager import Repo
+from repo.manager import Repo
 from starbash.tool import Tool
-from starbash.repo import RepoManager
+from repo import RepoManager
 from starbash.tool import tools
 from starbash.paths import get_user_config_dir, get_user_data_dir
 from starbash.selection import Selection
@@ -34,11 +34,12 @@ def setup_logging():
     """
     Configures basic logging.
     """
+    handlers = [RichHandler(rich_tracebacks=True)] if not _is_test_env else []
     logging.basicConfig(
         level=starbash.log_filter_level,  # use the global log filter level
         format="%(message)s",
         datefmt="[%X]",
-        handlers=[RichHandler(rich_tracebacks=True)],
+        handlers=handlers,
     )
 
 
@@ -204,15 +205,11 @@ class Starbash:
             session = self.db.get_session(new)
             self.db.upsert_session(new, existing=session)
 
-    def search_session(self) -> list[dict[str, Any]] | None:
+    def search_session(self) -> list[dict[str, Any]]:
         """Search for sessions, optionally filtered by the current selection."""
-        # If selection has filters, use them; otherwise return all sessions
-        if self.selection.is_empty():
-            return self.db.search_session(None)
-        else:
-            # Get query conditions from selection
-            conditions = self.selection.get_query_conditions()
-            return self.db.search_session(conditions)
+        # Get query conditions from selection
+        conditions = self.selection.get_query_conditions()
+        return self.db.search_session(conditions)
 
     def get_session_images(self, session_id: int) -> list[dict[str, Any]]:
         """

starbash/commands/__init__.py

@@ -1,5 +1,12 @@
 """Shared utilities for starbash commands."""
 
+from datetime import datetime
+from rich.style import Style
+
+# Define reusable table styles
+TABLE_COLUMN_STYLE = Style(color="cyan")
+TABLE_VALUE_STYLE = Style(color="green")
+
 
 def format_duration(seconds: int | float) -> str:
     """Format seconds as a human-readable duration string."""
@@ -13,3 +20,20 @@ def format_duration(seconds: int | float) -> str:
         hours = int(seconds // 3600)
         minutes = int((seconds % 3600) // 60)
         return f"{hours}h {minutes}m" if minutes else f"{hours}h"
+
+
+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, or the original string if conversion fails
+    """
+    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

starbash/commands/info.py

@@ -2,44 +2,78 @@
 
 import typer
 from typing_extensions import Annotated
+from rich.table import Table
+from collections import Counter
 
 from starbash.app import Starbash
 from starbash import console
-from starbash.database import Database
+from starbash.database import Database, get_column_name
 from starbash.paths import get_user_config_dir, get_user_data_dir
-from starbash.commands import format_duration
+from starbash.commands import format_duration, TABLE_COLUMN_STYLE, TABLE_VALUE_STYLE
 
 app = typer.Typer()
 
 
+def plural(name: str) -> str:
+    """Return the plural form of a given noun (simple heuristic - FIXME won't work with i18n)."""
+    if name.endswith("y"):
+        return name[:-1] + "ies"
+    else:
+        return name + "s"
+
+
+def dump_column(sb: Starbash, human_name: str, column_name: str) -> None:
+    # Get all telescopes from the database
+    sessions = sb.search_session()
+
+    # Also do a complete unfiltered search so we can compare for the users
+    allsessions = sb.db.search_session()
+
+    column_name = get_column_name(column_name)
+    found = [session[column_name] for session in sessions if session[column_name]]
+    allfound = [session[column_name] for session in allsessions if session[column_name]]
+
+    # Count occurrences of each telescope
+    found_counts = Counter(found)
+    all_counts = Counter(allfound)
+
+    # Sort by telescope name
+    sorted_telescopes = sorted(found_counts.items())
+
+    # Create and display table
+    table = Table(
+        title=f"{plural(human_name)} ({len(found_counts)} / {len(all_counts)} selected)"
+    )
+    table.add_column(human_name, style=TABLE_COLUMN_STYLE, no_wrap=False)
+    table.add_column(
+        "# of sessions", style=TABLE_COLUMN_STYLE, no_wrap=True, justify="right"
+    )
+
+    for i, count in sorted_telescopes:
+        table.add_row(i, str(count))
+
+    console.print(table)
+
+
 @app.command()
 def target():
     """List targets (filtered based on the current selection)."""
     with Starbash("info.target") as sb:
-        console.print("[yellow]Not yet implemented[/yellow]")
-        console.print(
-            "This command will list all unique targets in the current selection."
-        )
+        dump_column(sb, "Target", Database.OBJECT_KEY)
 
 
 @app.command()
 def telescope():
     """List telescopes/instruments (filtered based on the current selection)."""
     with Starbash("info.telescope") as sb:
-        console.print("[yellow]Not yet implemented[/yellow]")
-        console.print(
-            "This command will list all unique telescopes in the current selection."
-        )
+        dump_column(sb, "Telescope", Database.TELESCOP_KEY)
 
 
 @app.command()
 def filter():
-    """List all filters found in current selection."""
+    """List all filters (filtered based on the current selection)."""
     with Starbash("info.filter") as sb:
-        console.print("[yellow]Not yet implemented[/yellow]")
-        console.print(
-            "This command will list all unique filters in the current selection."
-        )
+        dump_column(sb, "Filter", Database.FILTER_KEY)
 
 
 @app.callback(invoke_without_command=True)
@@ -50,15 +84,13 @@ def main_callback(ctx: typer.Context):
     """
     if ctx.invoked_subcommand is None:
         with Starbash("info") as sb:
-            from rich.table import Table
-
             table = Table(title="Starbash Information")
-            table.add_column("Setting", style="cyan", no_wrap=True)
-            table.add_column("Value", style="green")
+            table.add_column("Setting", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("Value", style=TABLE_VALUE_STYLE)
 
             # Show config and data directories
-            table.add_row("Config Directory", str(get_user_config_dir()))
-            table.add_row("Data Directory", str(get_user_data_dir()))
+            # table.add_row("Config Directory", str(get_user_config_dir()))
+            # table.add_row("Data Directory", str(get_user_data_dir()))
 
             # Show user preferences if set
             user_name = sb.user_repo.get("user.name")
@@ -69,10 +101,6 @@ def main_callback(ctx: typer.Context):
             if user_email:
                 table.add_row("User Email", str(user_email))
 
-            # Show analytics setting
-            analytics_enabled = sb.user_repo.get("analytics.enabled", True)
-            table.add_row("Analytics", "Enabled" if analytics_enabled else "Disabled")
-
             # Show number of repos
             table.add_row("Total Repositories", str(len(sb.repo_manager.repos)))
             table.add_row("User Repositories", str(len(sb.repo_manager.regular_repos)))

starbash/commands/select.py

@@ -1,6 +1,7 @@
 """Selection commands for filtering sessions and targets."""
 
 import os
+from typing import Any
 import typer
 from pathlib import Path
 from typing_extensions import Annotated
@@ -8,9 +9,14 @@ from datetime import datetime
 from rich.table import Table
 
 from starbash.app import Starbash, copy_images_to_dir
-from starbash.database import Database
+from starbash.database import Database, get_column_name
 from starbash import console
-from starbash.commands import format_duration
+from starbash.commands import (
+    format_duration,
+    to_shortdate,
+    TABLE_COLUMN_STYLE,
+    TABLE_VALUE_STYLE,
+)
 
 app = typer.Typer()
 
@@ -127,14 +133,14 @@ def list_sessions():
             sb.analytics.set_data("session.num_selected", len(sessions))
             sb.analytics.set_data("session.num_total", len_all)
 
-            table.add_column("#", style="cyan", no_wrap=True)
-            table.add_column("Date", style="cyan", no_wrap=True)
-            table.add_column("# images", style="cyan", no_wrap=True)
-            table.add_column("Time", style="cyan", no_wrap=True)
-            table.add_column("Type/Filter", style="cyan", no_wrap=True)
-            table.add_column("Telescope", style="cyan", no_wrap=True)
+            table.add_column("#", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("Date", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("# images", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("Time", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("Type/Filter", style=TABLE_COLUMN_STYLE, no_wrap=True)
+            table.add_column("Telescope", style=TABLE_COLUMN_STYLE, no_wrap=True)
             table.add_column(
-                "About", style="cyan", no_wrap=True
+                "About", style=TABLE_COLUMN_STYLE, no_wrap=True
             )  # type of frames, filter, target
 
             total_images = 0
@@ -143,26 +149,25 @@ def list_sessions():
             image_types = set()
             telescopes = set()
 
+            def get_key(k: str, default: Any = "N/A") -> Any:
+                """Convert keynames to SQL legal column names"""
+                k = get_column_name(k)
+                return sess.get(k, default)
+
             for session_index, sess in enumerate(sessions):
-                date_iso = sess.get(Database.START_KEY, "N/A")
-                # Try to convert ISO UTC datetime to local short date string
-                try:
-                    dt_utc = datetime.fromisoformat(date_iso)
-                    dt_local = dt_utc.astimezone()
-                    date = dt_local.strftime("%Y-%m-%d")
-                except (ValueError, TypeError):
-                    date = date_iso
+                date_iso = get_key(Database.START_KEY)
+                date = to_shortdate(date_iso)
 
-                object = str(sess.get(Database.OBJECT_KEY, "N/A"))
-                filter = sess.get(Database.FILTER_KEY, "N/A")
+                object = get_key(Database.OBJECT_KEY)
+                filter = get_key(Database.FILTER_KEY)
                 filters.add(filter)
-                image_type = str(sess.get(Database.IMAGETYP_KEY, "N/A"))
+                image_type = get_key(Database.IMAGETYP_KEY)
                 image_types.add(image_type)
-                telescope = str(sess.get(Database.TELESCOP_KEY, "N/A"))
+                telescope = get_key(Database.TELESCOP_KEY)
                 telescopes.add(telescope)
 
                 # Format total exposure time as integer seconds
-                exptime_raw = str(sess.get(Database.EXPTIME_TOTAL_KEY, "N/A"))
+                exptime_raw = get_key(Database.EXPTIME_TOTAL_KEY)
                 try:
                     exptime_float = float(exptime_raw)
                     total_seconds += exptime_float
@@ -172,10 +177,10 @@ def list_sessions():
 
                 # Count images
                 try:
-                    num_images = int(sess.get(Database.NUM_IMAGES_KEY, 0))
+                    num_images = int(get_key(Database.NUM_IMAGES_KEY, 0))
                     total_images += num_images
                 except (ValueError, TypeError):
-                    num_images = sess.get(Database.NUM_IMAGES_KEY, "N/A")
+                    num_images = get_key(Database.NUM_IMAGES_KEY)
 
                 type_str = image_type
                 if image_type.upper() == "LIGHT":
@@ -300,8 +305,8 @@ def show_selection(ctx: typer.Context):
                 console.print(f"[yellow]{summary['message']}[/yellow]")
             else:
                 table = Table(title="Current Selection")
-                table.add_column("Criteria", style="cyan")
-                table.add_column("Value", style="green")
+                table.add_column("Criteria", style=TABLE_COLUMN_STYLE)
+                table.add_column("Value", style=TABLE_VALUE_STYLE)
 
                 for criterion in summary["criteria"]:
                     parts = criterion.split(": ", 1)

starbash/database.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import sqlite3
 from pathlib import Path
 from typing import Any, Optional
@@ -10,6 +9,14 @@ import json
 from .paths import get_user_data_dir
 
 
+def get_column_name(k: str) -> str:
+    """Convert keynames to SQL legal column names"""
+    k = k.lower()
+    k = k.replace(" ", "_")
+    k = k.replace("-", "_")
+    return k
+
+
 class Database:
     """SQLite-backed application database.
 
@@ -220,9 +227,56 @@ class Database:
 
         return results if results else None
 
+    def where_session(self, conditions: dict[str, Any] | None) -> tuple[str, list[Any]]:
+        """Search for sessions matching the given conditions.
+
+        Args:
+            conditions: Dictionary of session key-value pairs to match, or None for all.
+                       Special keys:
+                       - 'date_start': Filter sessions starting on or after this date
+                       - 'date_end': Filter sessions starting on or before this date
+
+        Returns:
+            Tuple of (WHERE clause string, list of parameters)
+        """
+        if conditions is None:
+            conditions = {}
+
+        # Build WHERE clause dynamically based on conditions
+        where_clauses = []
+        params = []
+
+        # Extract date range conditions
+        date_start = conditions.get("date_start")
+        date_end = conditions.get("date_end")
+
+        # Add date range filters to WHERE clause
+        if date_start:
+            where_clauses.append("start >= ?")
+            params.append(date_start)
+
+        if date_end:
+            where_clauses.append("start <= ?")
+            params.append(date_end)
+
+        # Add standard conditions to WHERE clause
+        for key, value in conditions.items():
+            if key not in ("date_start", "date_end") and value is not None:
+                column_name = key
+                where_clauses.append(f"{column_name} = ?")
+                params.append(value)
+
+        # Build the query
+        query = ""
+
+        if where_clauses:
+            query += " WHERE " + " AND ".join(where_clauses)
+
+        return (query, params)
+
     def search_session(
-        self, conditions: dict[str, Any] | None
-    ) -> list[dict[str, Any]] | None:
+        self, conditions: dict[str, Any] | None = None
+    ) -> list[dict[str, Any]]:
         """Search for sessions matching the given conditions.
 
         Args:
@@ -235,59 +289,24 @@ class Database:
             List of matching session records or None
         """
         if conditions is None:
-            return self.all_sessions()
+            conditions = {}
 
-        cursor = self._db.cursor()
-        cursor.execute(
-            f"""
+        # Build WHERE clause dynamically based on conditions
+        where_clause, params = self.where_session(conditions)
+
+        # Build the query
+        query = f"""
             SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
             FROM {self.SESSIONS_TABLE}
+            {where_clause}
         """
-        )
-
-        # Extract date range conditions if present
-        date_start = conditions.get("date_start")
-        date_end = conditions.get("date_end")
-
-        # Create a copy without date range keys for standard matching
-        standard_conditions = {
-            k: v
-            for k, v in conditions.items()
-            if k not in ("date_start", "date_end") and v is not None
-        }
-
-        results = []
-        for row in cursor.fetchall():
-            session = {
-                "id": row["id"],
-                self.START_KEY: row["start"],
-                self.END_KEY: row["end"],
-                self.FILTER_KEY: row["filter"],
-                self.IMAGETYP_KEY: row["imagetyp"],
-                self.OBJECT_KEY: row["object"],
-                self.TELESCOP_KEY: row["telescop"],
-                self.NUM_IMAGES_KEY: row["num_images"],
-                self.EXPTIME_TOTAL_KEY: row["exptime_total"],
-                self.IMAGE_DOC_KEY: row["image_doc_id"],
-            }
-
-            # Check if all standard conditions match
-            match = all(session.get(k) == v for k, v in standard_conditions.items())
-
-            # Apply date range filtering
-            if match and date_start:
-                session_start = session.get(self.START_KEY, "")
-                match = match and session_start >= date_start
-
-            if match and date_end:
-                session_start = session.get(self.START_KEY, "")
-                match = match and session_start <= date_end
 
-            if match:
-                results.append(session)
+        cursor = self._db.cursor()
+        cursor.execute(query, params)
 
-        return results if results else None
+        results = [dict(row) for row in cursor.fetchall()]
+        return results
 
     def len_table(self, table_name: str) -> int:
         """Return the total number of rows in the specified table."""
@@ -361,35 +380,6 @@ class Database:
 
         return results
 
-    def all_sessions(self) -> list[dict[str, Any]]:
-        """Return all session records."""
-        cursor = self._db.cursor()
-        cursor.execute(
-            f"""
-            SELECT id, start, end, filter, imagetyp, object, telescop,
-                   num_images, exptime_total, image_doc_id
-            FROM {self.SESSIONS_TABLE}
-        """
-        )
-
-        results = []
-        for row in cursor.fetchall():
-            session = {
-                "id": row["id"],
-                self.START_KEY: row["start"],
-                self.END_KEY: row["end"],
-                self.FILTER_KEY: row["filter"],
-                self.IMAGETYP_KEY: row["imagetyp"],
-                self.OBJECT_KEY: row["object"],
-                self.TELESCOP_KEY: row["telescop"],
-                self.NUM_IMAGES_KEY: row["num_images"],
-                self.EXPTIME_TOTAL_KEY: row["exptime_total"],
-                self.IMAGE_DOC_KEY: row["image_doc_id"],
-            }
-            results.append(session)
-
-        return results
-
     def get_session_by_id(self, session_id: int) -> dict[str, Any] | None:
         """Get a session record by its ID.
 
@@ -414,18 +404,7 @@ class Database:
         if row is None:
             return None
 
-        return {
-            "id": row["id"],
-            self.START_KEY: row["start"],
-            self.END_KEY: row["end"],
-            self.FILTER_KEY: row["filter"],
-            self.IMAGETYP_KEY: row["imagetyp"],
-            self.OBJECT_KEY: row["object"],
-            self.TELESCOP_KEY: row["telescop"],
-            self.NUM_IMAGES_KEY: row["num_images"],
-            self.EXPTIME_TOTAL_KEY: row["exptime_total"],
-            self.IMAGE_DOC_KEY: row["image_doc_id"],
-        }
+        return dict(row)
 
     def get_session(self, to_find: dict[str, str]) -> dict[str, Any] | None:
         """Find a session matching the given criteria.
@@ -470,18 +449,7 @@ class Database:
         if row is None:
             return None
 
-        return {
-            "id": row["id"],
-            self.START_KEY: row["start"],
-            self.END_KEY: row["end"],
-            self.FILTER_KEY: row["filter"],
-            self.IMAGETYP_KEY: row["imagetyp"],
-            self.OBJECT_KEY: row["object"],
-            self.TELESCOP_KEY: row["telescop"],
-            self.NUM_IMAGES_KEY: row["num_images"],
-            self.EXPTIME_TOTAL_KEY: row["exptime_total"],
-            self.IMAGE_DOC_KEY: row["image_doc_id"],
-        }
+        return dict(row)
 
     def upsert_session(
         self, new: dict[str, Any], existing: dict[str, Any] | None = None

{starbash-0.1.6.dist-info → starbash-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: starbash
-Version: 0.1.6
+Version: 0.1.7
 Summary: A tool for automating/standardizing/sharing astrophotography workflows.
 License-File: LICENSE
 Author: Kevin Hester
@@ -22,20 +22,31 @@ Description-Content-Type: text/markdown
 
 # Starbash
 
+<img src="https://raw.githubusercontent.com/geeksville/starbash/refs/heads/main/img/icon.png" alt="Starbash: Astrophotography workflows simplified" width="30%" align="right" style="margin-bottom: 20px;">
+
 [![PyPI - Version](https://img.shields.io/pypi/v/starbash)](https://pypi.org/project/starbash/)
 [![GitHub branch check runs](https://img.shields.io/github/check-runs/geeksville/starbash/main)](https://github.com/geeksville/starbash/actions)
 [![codecov](https://codecov.io/github/geeksville/starbash/graph/badge.svg?token=47RE10I7O1)](https://codecov.io/github/geeksville/starbash)
 
- ![app icon](https://raw.githubusercontent.com/geeksville/starbash/refs/heads/main/img/icon.png "Starbash: Astrophotography workflows simplified")
-
 A tool for automating/standardizing/sharing astrophotography workflows.
 
+* Automatic - with sensible defaults, that you can change as needed.
+* Easy - provides a 'seestar like' starting-point for autoprocessing all your sessions (by default).
+* Fast - even with large image repositories.  Automatic master bias and flat generation and reasonable defaults
+* Sharable - you can share/use recipes for image preprocessing flows.
+
+(This project is currently 'alpha' and missing recipes for some workflows, but adding new recipes is easy and we're happy to help.  Please file a github issue if your images are not auto-processed and we'll work out a fix.)
+
+<br clear="right">
+
 # Current status
 
 Not quite ready 😊.  But making good progress.
 
 See the current [TODO](TODO.md) file for work items.  I'll be looking for pre-alpha testers/feedback soon.
 
+![Sample session movie](https://raw.githubusercontent.com/geeksville/starbash/refs/heads/main/doc/vhs/sample-session.gif)
+
 ## Current features
 
 * Automatically recognizes and auto-parses the default NINA, Asiair and Seestar raw file repos (adding support for other layouts is easy)
@@ -56,15 +67,20 @@ See the current [TODO](TODO.md) file for work items.  I'll be looking for pre-al
 
 Currently the easiest way to install this command-line based tool is to install is via [pipx](https://pipx.pypa.io/stable/).  If you don't already have pipx and you have python installed, you can auto install it by running "pip install --user pipx."  If you don't have python installed see the pipx link for pipx installers for any OS.
 
-Once pipx is installed just run:
+Once pipx is installed just run the following **two** commands (the sb --install-completion will make TAB auto-complete automatically complete sb options (for most platforms)):
 
 ```
-pipx install starbash
+➜ pipx install starbash
   installed package starbash 0.1.3, installed using Python 3.12.3
   These apps are now globally available
     - sb
     - starbash
 done! ✨ 🌟 ✨
+
+➜ sb --install-completion
+bash completion installed in /home/.../sb.sh
+Completion will take effect once you restart the terminal
+
 ```
 
 FIXME - add getting started instructions (possibly with a screenshare video)

{starbash-0.1.6.dist-info → starbash-0.1.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
-starbash/__init__.py,sha256=nRJWVExYaZFtpk6nIi7zqmR53Ts5fA92OEvNVoIV8Ek,260
-starbash/analytics.py,sha256=MrrN9gL-cI5qNI3hGzGhrRefjvAB4z5XXN94f4zO9EQ,4256
-starbash/app.py,sha256=_rTanRxsnq1I6yXO_PA2XTVnkkGnD6LHYkl_7evtKSg,18068
-starbash/commands/__init__.py,sha256=6HD8Pssea0AiKCpucVi5bp3whjEx3neJT2H9c-PeG28,532
-starbash/commands/info.py,sha256=n5h9yQp1maSczNPyxvPPGxlbXCLMqFLke5HAmik8d-k,3240
+starbash/__init__.py,sha256=JNkBTu--Wf10eSHDwcpMS2hOp1VeTHmOGAcKPSlLbyo,618
+starbash/analytics.py,sha256=J1J8oXGZkdovXNkqOYGv12vl3p5EZEXHSXpcMrnUwzE,4122
+starbash/app.py,sha256=-dx92jUc7_jOJEsncubiRy5SUqMy10343MlRcm1zd9k,17921
+starbash/commands/__init__.py,sha256=J7XuX7EMXZg2EBJLvXmm8jAfyhY7Yt9bTvoDaptp0YU,1231
+starbash/commands/info.py,sha256=ebYQsieYzkuemCmiSIOwi7EzKJZd7W5oCdprgu3l3Tk,4135
 starbash/commands/repo.py,sha256=nPtt7vtkq0lMwkrL8qgsptV26MEathbPp3X2fVBn_ug,4950
-starbash/commands/select.py,sha256=hSlL_KzxaHKX8rv38HYVVVouKAu8Mlp4TAV6yS6COXo,11323
+starbash/commands/select.py,sha256=mjehAiIPg_v7IZ_IAgNTXxpHjYIcAlV9oGPCLiYHbT4,11371
 starbash/commands/user.py,sha256=MIJFhhWokoaBiZ6rKqQaSVxSvO_glwG5dTGhaZy-6PA,4249
-starbash/database.py,sha256=R6S_sUr048p35NEd_gN0v1Dlzrubjc1SX7KNMj3D7lg,19052
+starbash/database.py,sha256=w7QzgtupzfGsKoSoBsHCHhukNr2RQnAO323LCWas5dI,17539
 starbash/defaults/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 starbash/defaults/starbash.toml,sha256=gciQjE2Q5QgS1aUph9Y4icI0xpYeDOALkzpAjZiabIk,1737
 starbash/main.py,sha256=BFmR-jP6RsXh9q6Gl3_3_F_4mMkYwEBhmox6fpz0Cyo,1492
@@ -19,15 +19,13 @@ starbash/recipes/osc_dual_duo/starbash.py,sha256=2cI4L6-d50-mL4hY0Oe6ad1v7g18D7u
 starbash/recipes/osc_dual_duo/starbash.toml,sha256=xh3zEqdotRZr7eUcqel-xnQcWH8z-PUFRuWQfLp3F_E,3195
 starbash/recipes/osc_single_duo/starbash.toml,sha256=kB-FMek0Z-8vieUfxKqmZMFNnZsSKdufSkLSgH03CkY,2117
 starbash/recipes/starbash.toml,sha256=iZs0nLGY1kox0wa5ZzX9t2xTffy4Jbu_Q221Egnsml8,1019
-starbash/repo/__init__.py,sha256=TqspuLjPSNnO38tvCGa0fJvvasgecHl6fE7m0-Lj8ho,148
-starbash/repo/manager.py,sha256=Fc_akPK7D8sw3961DM5BCQ7O27tnEdAutg8TSNiopgI,13903
 starbash/selection.py,sha256=DPzUlls3n-sBqkwTUns2ZNaPi61PGnh7Z_ZQOC1jXYc,8347
 starbash/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 starbash/templates/userconfig.toml,sha256=LCV69jAxLrIPXrkt6U-gU4KLKeb9MHCD1ownqG211Ns,1442
 starbash/tool.py,sha256=S1kOTbeHTrA0meqwftgL0SA4VhJdZWWx2h1Wtwu1Izg,8749
 starbash/url.py,sha256=lorxQJ27jSfzsKCb0QvpcvLiPZG55Dkd_c1JPFbni4I,402
-starbash-0.1.6.dist-info/METADATA,sha256=pR7UYA49K2goimDRGMwsg1Y_p4MdO0lkDP6OrMKjYZ0,6156
-starbash-0.1.6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-starbash-0.1.6.dist-info/entry_points.txt,sha256=REQyWs8e5TJsNK7JVVWowKVoytMmKlUwuFHLTmSX4hc,67
-starbash-0.1.6.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-starbash-0.1.6.dist-info/RECORD,,
+starbash-0.1.7.dist-info/METADATA,sha256=GkrnXHF6cmTDWpGzXmUYDkscIlnXszGiLuZB21I6QXU,7215
+starbash-0.1.7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+starbash-0.1.7.dist-info/entry_points.txt,sha256=REQyWs8e5TJsNK7JVVWowKVoytMmKlUwuFHLTmSX4hc,67
+starbash-0.1.7.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+starbash-0.1.7.dist-info/RECORD,,

starbash/repo/__init__.py

@@ -1,7 +0,0 @@
-"""
-The repo package handles finding, loading and searching starbash repositories.
-"""
-
-from .manager import RepoManager
-
-__all__ = ["RepoManager"]

starbash/repo/manager.py

@@ -1,381 +0,0 @@
-"""
-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
-
-
-repo_suffix = "starbash.toml"
-
-REPO_REF = "repo-ref"
-
-
-class Repo:
-    """
-    Represents a single starbash repository."""
-
-    def __init__(self, manager: RepoManager, url: str):
-        """
-        Initializes a Repo instance.
-
-        Args:
-            url: The URL to the repository (file or general http/https urls are acceptable).
-        """
-        self.manager = manager
-        self.url = url
-        self.config = self._load_config()
-
-    def __str__(self) -> str:
-        """Return a concise one-line description of this repo.
-
-        Example: "Repo(kind=recipe, local=True, url=file:///path/to/repo)"
-        """
-        return f"Repo(kind={self.kind}, url={self.url})"
-
-    __repr__ = __str__
-
-    def kind(self, unknown_kind: str = "unknown") -> str:
-        """
-        Read-only attribute for the repository kind (e.g., "recipe", "data", etc.).
-
-        Returns:
-            The kind of the repository as a string.
-        """
-        c = self.get("repo.kind", unknown_kind)
-        return str(c)
-
-    def add_repo_ref(self, dir: str) -> 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())
-
-        # Add the ref to this repo
-        aot = self.config.get(REPO_REF, None)
-        if aot is None:
-            aot = tomlkit.aot()
-            self.config[REPO_REF] = aot  # add an empty AoT at the end of the file
-
-        if type(aot) is not AoT:
-            raise ValueError(f"repo-ref in {self.url} is not an array")
-
-        for t in aot:
-            if "dir" in t and t["dir"] == dir:
-                logging.warning(f"Repo ref {dir} already exists - ignoring.")
-                return None  # already exists
-
-        ref = {"dir": dir}
-        aot.append(ref)
-
-        # Also add the repo to the manager
-        return self.add_from_ref(ref)
-
-    def write_config(self) -> None:
-        """
-        Writes the current (possibly modified) configuration back to the repository's config file.
-
-        Raises:
-            ValueError: If the repository is not a local file repository.
-        """
-        base_path = self.get_path()
-        if base_path is None:
-            raise ValueError("Cannot resolve path for non-local repository")
-
-        config_path = base_path / repo_suffix
-        # FIXME, be more careful to write the file atomically (by writing to a temp file and renaming)
-        TOMLFile(config_path).write(self.config)
-        logging.debug(f"Wrote config to {config_path}")
-
-    def is_scheme(self, scheme: str = "file") -> bool:
-        """
-        Read-only attribute indicating whether the repository URL points to a
-        local file system path (file:// scheme).
-
-        Returns:
-            bool: True if the URL is a local file path, False otherwise.
-        """
-        return self.url.startswith(f"{scheme}://")
-
-    def get_path(self) -> Path | None:
-        """
-        Resolves the URL to a local file system path if it's a file URI.
-
-        Args:
-            url: The repository URL.
-
-        Returns:
-            A Path object if the URL is a local file, otherwise None.
-        """
-        if self.is_scheme("file"):
-            return Path(self.url[len("file://") :])
-
-        return None
-
-    def add_from_ref(self, ref: dict) -> Repo:
-        """
-        Adds a repository based on a repo-ref dictionary.
-        """
-        if "url" in ref:
-            url = ref["url"]
-        elif "dir" in ref:
-            # FIXME don't allow ~ or .. in file paths for security reasons?
-            if self.is_scheme("file"):
-                path = Path(ref["dir"])
-                base_path = self.get_path()
-
-                if base_path and not path.is_absolute():
-                    # Resolve relative to the current TOML file's directory
-                    path = (base_path / path).resolve()
-                else:
-                    # Expand ~ and resolve from CWD
-                    path = path.expanduser().resolve()
-                url = f"file://{path}"
-            else:
-                # construct an URL relative to this repo's URL
-                url = self.url.rstrip("/") + "/" + ref["dir"].lstrip("/")
-        else:
-            raise ValueError(f"Invalid repo reference: {ref}")
-        return self.manager.add_repo(url)
-
-    def add_by_repo_refs(self) -> None:
-        """Add all repos mentioned by repo-refs in this repo's config."""
-        repo_refs = self.config.get(REPO_REF, [])
-
-        for ref in repo_refs:
-            self.add_from_ref(ref)
-
-    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.
-        """
-        base_path = self.get_path()
-        if base_path is None:
-            raise ValueError("Cannot read files from non-local repositories")
-        target_path = (base_path / filepath).resolve()
-
-        # Security check to prevent reading 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')                   │                                                                                          │
-        #   filepath = 'starbash.toml'                                              │                                                                                          │
-        #   self = <repr-error 'maximum recursion depth exceeded'>              │                                                                                          │
-        #   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")
-
-        return target_path.read_text()
-
-    def _read_resource(self, filepath: str) -> str:
-        """
-        Read a resource from the installed starbash package using a pkg:// URL.
-
-        Assumptions (simplified per project constraints):
-        - All pkg URLs point somewhere inside the already-imported 'starbash' package.
-        - The URL is treated as a path relative to the starbash package root.
-
-        Examples:
-            url: pkg://defaults   + filepath: "starbash.toml"
-              -> reads starbash/defaults/starbash.toml
-
-        Args:
-            filepath: Path within the base resource directory for this repo.
-
-        Returns:
-            The content of the resource as a string (UTF-8).
-        """
-        # Path portion after pkg://, interpreted relative to the 'starbash' package
-        subpath = self.url[len("pkg://") :].strip("/")
-
-        res = resources.files("starbash").joinpath(subpath).joinpath(filepath)
-        return res.read_text()
-
-    def _load_config(self) -> tomlkit.TOMLDocument:
-        """
-        Loads the repository's configuration file (e.g., repo.sb.toml).
-
-        If the config file does not exist, it logs a warning and returns an empty dict.
-
-        Returns:
-            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}")
-            logging.debug(f"Loading repo config from {repo_suffix}")
-            return tomlkit.parse(config_content)
-        except FileNotFoundError:
-            logging.debug(
-                f"No {repo_suffix} found"
-            )  # we currently make it optional to have the config file at root
-            return tomlkit.TOMLDocument()  # empty placeholder
-
-    def get(self, key: str, default: Any | None = None) -> Any | None:
-        """
-        Gets a value from this repo's config for a given key.
-        The key can be a dot-separated string for nested values.
-
-        Args:
-            key: The dot-separated key to search for (e.g., "repo.kind").
-            default: The value to return if the key is not found.
-
-        Returns:
-            The found value or the default.
-        """
-        value = self.config
-        for k in key.split("."):
-            if not isinstance(value, dict):
-                return default
-            value = value.get(k)
-        return value if value is not None else default
-
-    def set(self, key: str, value: Any) -> None:
-        """
-        Sets a value in this repo's config for a given key.
-        The key can be a dot-separated string for nested values.
-        Creates nested Table structures as needed.
-
-        Args:
-            key: The dot-separated key to set (e.g., "repo.kind").
-            value: The value to set.
-
-        Example:
-            repo.set("repo.kind", "preferences")
-            repo.set("user.name", "John Doe")
-        """
-        keys = key.split(".")
-        current: Any = self.config
-
-        # Navigate/create nested structure for all keys except the last
-        for k in keys[:-1]:
-            if k not in current:
-                # Create a new nested table
-                current[k] = tomlkit.table()
-            elif not isinstance(current[k], dict):
-                # Overwrite non-dict value with a table
-                current[k] = tomlkit.table()
-            current = current[k]
-
-        # 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)