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

starbash/check_version.py

@@ -0,0 +1,18 @@
+import logging
+from importlib.metadata import PackageNotFoundError, version
+
+from update_checker import UpdateChecker
+
+
+def check_version():
+    """Check if a newer version of starbash is available on PyPI."""
+    try:
+        checker = UpdateChecker()
+        current_version = version("starbash")
+        result = checker.check("starbash", current_version)
+        if result:
+            logging.warning(result)
+
+    except PackageNotFoundError:
+        # Package not installed (e.g., running from source during development)
+        pass

starbash/commands/__init__.py

@@ -1,11 +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")
+TABLE_HEADER_STYLE = Style(color="magenta", bold=True)
+SPINNER_STYLE = Style(color="magenta", bold=True)
 
 
 def format_duration(seconds: int | float) -> str:

starbash/commands/info.py

@@ -1,15 +1,19 @@
 """Info commands for displaying system and data information."""
 
+from collections import Counter
+from typing import Annotated
+
 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.commands import (
+    TABLE_COLUMN_STYLE,
+    TABLE_HEADER_STYLE,
+    TABLE_VALUE_STYLE,
+    format_duration,
+)
 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, TABLE_COLUMN_STYLE, TABLE_VALUE_STYLE
 
 app = typer.Typer()
 
@@ -27,7 +31,7 @@ def dump_column(sb: Starbash, human_name: str, column_name: str) -> None:
     sessions = sb.search_session()
 
     # Also do a complete unfiltered search so we can compare for the users
-    allsessions = sb.db.search_session(("", []))
+    allsessions = sb.db.search_session([])
 
     column_name = get_column_name(column_name)
     found = [session[column_name] for session in sessions if session[column_name]]
@@ -42,16 +46,17 @@ def dump_column(sb: Starbash, human_name: str, column_name: str) -> None:
 
     # Create and display table
     table = Table(
-        title=f"{plural(human_name)} ({len(found_counts)} / {len(all_counts)} selected)"
+        header_style=TABLE_HEADER_STYLE,
+        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"
-    )
+    table.add_column("# of sessions", style=TABLE_COLUMN_STYLE, no_wrap=True, justify="right")
 
     for i, count in sorted_list:
         table.add_row(i, str(count))
 
+    from starbash import console
+
     console.print(table)
 
 
@@ -76,15 +81,86 @@ def filter():
         dump_column(sb, "Filter", Database.FILTER_KEY)
 
 
+kind_arg = typer.Argument(
+    help="Optional image type to filter by (e.g., BIAS, DARK, FLAT, LIGHT)",
+)
+
+
+@app.command()
+def master(
+    kind: Annotated[
+        str | None,
+        kind_arg,
+    ] = None,
+):
+    """List all precalculated master images (darks, biases, flats)."""
+    with Starbash("info.master") as sb:
+        from starbash import console
+
+        # Get the master repo
+        images = sb.get_master_images(kind)
+
+        if not images:
+            kind_msg = f" of type '{kind}'" if kind else ""
+            console.print(f"[yellow]No master images{kind_msg} found.[/yellow]")
+            return
+
+        # Create table to display results
+        title = f"Master Images ({len(images)} total)"
+        if kind:
+            title = f"Master {kind} Images ({len(images)} total)"
+        table = Table(title=title, header_style=TABLE_HEADER_STYLE)
+        table.add_column("Date", style=TABLE_COLUMN_STYLE, no_wrap=True)
+        table.add_column("Type", style=TABLE_COLUMN_STYLE, no_wrap=True)
+        table.add_column("Filename", style=TABLE_VALUE_STYLE, no_wrap=False)
+
+        # Sort by date, then by type
+        sorted_images = sorted(
+            images,
+            key=lambda img: (
+                img.get(Database.DATE_OBS_KEY) or img.get(Database.DATE_KEY) or "",
+                img.get(Database.IMAGETYP_KEY) or "",
+            ),
+        )
+
+        for image in sorted_images:
+            date = image.get(Database.DATE_OBS_KEY) or image.get(Database.DATE_KEY) or "Unknown"
+            # Extract just the date part (YYYY-MM-DD) if it's a full ISO timestamp
+            if "T" in date:
+                date = date.split("T")[0]
+
+            kind = image.get(Database.IMAGETYP_KEY)
+            if kind:
+                kind = sb.aliases.normalize(kind)
+            filename = image.get("path") or "Unknown"
+
+            table.add_row(date, kind, filename)
+
+        console.print(table)
+
+
+@app.command(hidden=True)
+def masters(
+    kind: Annotated[
+        str | None,
+        kind_arg,
+    ] = None,
+):
+    """Alias for 'info master' command."""
+    master(kind)
+
+
 @app.callback(invoke_without_command=True)
 def main_callback(ctx: typer.Context):
     """Show user preferences location and other app info.
 
     This is the default command when no subcommand is specified.
     """
+    from starbash import console
+
     if ctx.invoked_subcommand is None:
         with Starbash("info") as sb:
-            table = Table(title="Starbash Information")
+            table = Table(title="Starbash Information", header_style=TABLE_HEADER_STYLE)
             table.add_column("Setting", style=TABLE_COLUMN_STYLE, no_wrap=True)
             table.add_column("Value", style=TABLE_VALUE_STYLE)
 
@@ -106,9 +182,7 @@ def main_callback(ctx: typer.Context):
             table.add_row("User Repositories", str(len(sb.repo_manager.regular_repos)))
 
             # Show database stats
-            table.add_row(
-                "Sessions Indexed", str(sb.db.len_table(Database.SESSIONS_TABLE))
-            )
+            table.add_row("Sessions Indexed", str(sb.db.len_table(Database.SESSIONS_TABLE)))
 
             table.add_row("Images Indexed", str(sb.db.len_table(Database.IMAGES_TABLE)))
 

starbash/commands/process.py

@@ -1,13 +1,19 @@
 """Processing commands for automated image processing workflows."""
 
-import typer
 from pathlib import Path
-from typing_extensions import Annotated
+from typing import Annotated
+
+import rich
+import typer
 
 from starbash.app import Starbash, copy_images_to_dir
-from starbash import console
+from starbash.commands.__init__ import (
+    TABLE_COLUMN_STYLE,
+    TABLE_HEADER_STYLE,
+)
 from starbash.commands.select import selection_by_number
 from starbash.database import SessionRow
+from starbash.processing import Processing, ProcessingResult
 
 app = typer.Typer()
 
@@ -20,9 +26,7 @@ def siril(
     ],
     destdir: Annotated[
         str,
-        typer.Argument(
-            help="Destination directory for Siril directory tree and processing"
-        ),
+        typer.Argument(help="Destination directory for Siril directory tree and processing"),
     ],
     run: Annotated[
         bool,
@@ -42,6 +46,8 @@ def siril(
     structure loaded and ready for processing.
     """
     with Starbash("process.siril") as sb:
+        from starbash import console
+
         console.print(
             f"[yellow]Processing session {session_num} for Siril in {destdir}...[/yellow]"
         )
@@ -67,9 +73,9 @@ def siril(
 
         extras = [
             # FIXME search for BIAS/DARK/FLAT etc... using multiple canonical names
-            ("BIAS", "biases"),
-            ("DARK", "darks"),
-            ("FLAT", "flats"),
+            ("bias", "biases"),
+            ("dark", "darks"),
+            ("flat", "flats"),
         ]
         for typ, subdir in extras:
             candidates = sb.guess_sessions(session, typ)
@@ -85,6 +91,48 @@ def siril(
         # Also FIXME, check for the existence of such a file
 
 
+def print_results(
+    title: str, results: list[ProcessingResult], console: rich.console.Console
+) -> None:
+    """Print processing results in a formatted table.
+
+    Args:
+        title: Title to display above the table
+        results: List of ProcessingResult objects to display
+        console: Rich console instance for output
+    """
+    from rich.table import Table
+
+    if not results:
+        console.print(f"[yellow]{title}: No results to display[/yellow]")
+        return
+
+    table = Table(title=title, show_header=True, header_style=TABLE_HEADER_STYLE)
+    table.add_column("Target", style=TABLE_COLUMN_STYLE, no_wrap=True)
+    table.add_column("Sessions", justify="right", style=TABLE_COLUMN_STYLE)
+    table.add_column("Status", justify="center", style=TABLE_COLUMN_STYLE)
+    table.add_column("Notes", style=TABLE_COLUMN_STYLE)
+
+    for result in results:
+        # Format status with color
+        if result.success is True:
+            status = "[green]✓ Success[/green]"
+        elif result.success is False:
+            status = "[red]✗ Failed[/red]"
+        else:
+            status = "[yellow]⊘ Skipped[/yellow]"
+
+        # Format session count
+        session_count = str(len(result.sessions))
+
+        # Format notes (truncate if too long)
+        notes = result.notes or ""
+
+        table.add_row(result.target, session_count, status, notes)
+
+    console.print(table)
+
+
 @app.command()
 def auto(
     session_num: Annotated[
@@ -109,15 +157,17 @@ def auto(
     The output will be saved according to the configured recipes.
     """
     with Starbash("process.auto") as sb:
-        if session_num is not None:
-            console.print(f"[yellow]Auto-processing session {session_num}...[/yellow]")
-        else:
-            console.print("[yellow]Auto-processing all selected sessions...[/yellow]")
+        with Processing(sb) as proc:
+            from starbash import console
 
-        console.print(
-            "[red]Still in development - see https://github.com/geeksville/starbash[/red]"
-        )
-        sb.run_all_stages()
+            if session_num is not None:
+                console.print(f"[yellow]Auto-processing session {session_num}...[/yellow]")
+            else:
+                console.print("[yellow]Auto-processing all selected sessions...[/yellow]")
+
+            results = proc.run_all_stages()
+
+            print_results("Autoprocessed", results, console)
 
 
 @app.command()
@@ -132,13 +182,13 @@ def masters():
     and will be automatically used for future processing operations.
     """
     with Starbash("process.masters") as sb:
-        console.print(
-            "[yellow]Generating master frames from current selection...[/yellow]"
-        )
-        console.print(
-            "[red]Still in development - see https://github.com/geeksville/starbash[/red]"
-        )
-        sb.run_master_stages()
+        with Processing(sb) as proc:
+            from starbash import console
+
+            console.print("[yellow]Generating master frames from current selection...[/yellow]")
+            results = proc.run_master_stages()
+
+            print_results("Generated masters", results, console)
 
 
 @app.callback(invoke_without_command=True)
@@ -149,6 +199,8 @@ def main_callback(ctx: typer.Context):
     post-processing of astrophotography sessions.
     """
     if ctx.invoked_subcommand is None:
+        from starbash import console
+
         # No command provided, show help
         console.print(ctx.get_help())
         raise typer.Exit()

starbash/commands/repo.py

@@ -1,13 +1,14 @@
-import typer
-from typing_extensions import Annotated
-from pathlib import Path
 import logging
+from textwrap import dedent
+from typing import Annotated
+
+import typer
 
 import starbash
-from repo import repo_suffix, Repo
+from repo import Repo
+from starbash import console
 from starbash.app import Starbash
-from starbash import console, log_filter_level
-from starbash.toml import toml_from_template
+from starbash.paths import get_user_documents_dir
 
 app = typer.Typer(invoke_without_command=True)
 
@@ -22,9 +23,7 @@ def repo_enumeration(sb: Starbash):
 
 def complete_repo_by_num(incomplete: str):
     # We need to use stderr_logging to prevent confusing the bash completion parser
-    starbash.log_filter_level = (
-        logging.ERROR
-    )  # avoid showing output while doing completion
+    starbash.log_filter_level = logging.ERROR  # avoid showing output while doing completion
     with Starbash("repo.complete.num", stderr_logging=True) as sb:
         for num, repo in repo_enumeration(sb).items():
             if str(num).startswith(incomplete):
@@ -33,9 +32,7 @@ def complete_repo_by_num(incomplete: str):
 
 def complete_repo_by_url(incomplete: str):
     # We need to use stderr_logging to prevent confusing the bash completion parser
-    starbash.log_filter_level = (
-        logging.ERROR
-    )  # avoid showing output while doing completion
+    starbash.log_filter_level = logging.ERROR  # avoid showing output while doing completion
     with Starbash("repo.complete.url", stderr_logging=True) as sb:
         repos = sb.repo_manager.regular_repos
 
@@ -45,28 +42,23 @@ def complete_repo_by_url(incomplete: str):
 
 
 @app.command()
-def list(
-    verbose: bool = typer.Option(
-        False, "--verbose", "-v", help="Show all repos including system repos"
-    ),
-):
+def list():
     """
     lists all repositories.
-    Use --verbose to show all repos including system/recipe repos.
     """
     with Starbash("repo.list") as sb:
-        repos = sb.repo_manager.repos if verbose else sb.repo_manager.regular_repos
+        repos = sb.repo_manager.repos if starbash.verbose_output else sb.repo_manager.regular_repos
         for i, repo in enumerate(repos):
             kind = repo.kind("input")
             # for unknown repos (probably because we haven't written a starbash.toml file to the root yet),
             # we call them "input" because users will be less confused by that
 
-            if verbose:
+            if starbash.verbose_output:
                 # No numbers for verbose mode (system repos can't be removed)
-                console.print(f"{ repo.url } (kind={ kind })")
+                console.print(f"{repo.url} (kind={kind})")
             else:
                 # Show numbers for user repos (can be removed later)
-                console.print(f"{ i + 1:2}: { repo.url } (kind={ kind })")
+                console.print(f"{i + 1:2}: {repo.url} (kind={kind})")
 
 
 @app.callback()
@@ -87,10 +79,15 @@ def main(
 
 @app.command()
 def add(
-    path: str,
+    path: Annotated[str | None, typer.Argument(help="Path to the respository")] = None,
     master: bool = typer.Option(
         False, "--master", help="Mark this new repository for master files."
     ),
+    processed: bool = typer.Option(
+        False,
+        "--processed",
+        help="Mark this new repository for processed output files.",
+    ),
 ):
     """
     Add a repository. path is either a local path or a remote URL.
@@ -98,43 +95,26 @@ def add(
     repo_type = None
     if master:
         repo_type = "master"
-    with Starbash("repo.add") as sb:
-        p = Path(path)
+    elif processed:
+        repo_type = "processed"
 
-        repo_toml = p / repo_suffix  # the starbash.toml file at the root of the repo
-        if repo_toml.exists():
-            logging.warning("Using existing repository config file: %s", repo_toml)
+    if path is None:
+        if repo_type is not None:
+            # if we know the repo type we can auto create a default path
+            path = str(get_user_documents_dir() / "repos" / repo_type)
         else:
-            if repo_type:
-                console.print(f"Creating {repo_type} repository: {p}")
-                p.mkdir(parents=True, exist_ok=True)
-
-                toml_from_template(
-                    f"repo/{repo_type}",
-                    p / repo_suffix,
-                    overrides={
-                        "REPO_TYPE": repo_type,
-                        "REPO_PATH": str(p),
-                        "DEFAULT_RELATIVE": "{instrument}/{date}/{imagetyp}/master_{imagetyp}.fits",
-                    },
-                )
-            else:
-                # No type specified, therefore (for now) assume we are just using this as an input
-                # repo (and it must exist)
-                if not p.exists():
-                    console.print(f"[red]Error: Repo path does not exist: {p}[/red]")
-                    raise typer.Exit(code=1)
-
-        console.print(f"Adding repository: {p}")
+            console.print("[red]Error: path is required for input repositories[/red]")
+            raise typer.Exit(1)
 
-        repo = sb.user_repo.add_repo_ref(p)
-        if repo:
-            sb.reindex_repo(repo)
+    with Starbash("repo.add") as sb:
+        if repo_type and sb.repo_manager.get_repo_by_kind(repo_type):
+            console.print(
+                dedent(f"""
+                       [red]Error[/red]: A repository for '{repo_type}' files already exists.  If you'd like to replace it, use 'sb repo remove <url|number>' first.""")
+            )
+            raise typer.Exit(1)
 
-            # we don't yet always write default config files at roots of repos, but it would be easy to add here
-            # r.write_config()
-            sb.user_repo.write_config()
-            # FIXME, we also need to index the newly added repo!!!
+        sb.add_local_repo(path, repo_type=repo_type)
 
 
 def repo_url_to_repo(sb: Starbash, repo_url: str | None) -> Repo | None:
@@ -173,9 +153,7 @@ def repo_url_to_repo(sb: Starbash, repo_url: str | None) -> Repo | None:
 def remove(
     reponum: Annotated[
         str,
-        typer.Argument(
-            help="Repository number or URL", autocompletion=complete_repo_by_url
-        ),
+        typer.Argument(help="Repository number or URL", autocompletion=complete_repo_by_url),
     ],
 ):
     """
@@ -186,7 +164,7 @@ def remove(
         # Get the repo to remove
         repo_to_remove = repo_url_to_repo(sb, reponum)
         if repo_to_remove is None:
-            console.print(f"[red]Error: You must specify a repository[/red]")
+            console.print("[red]Error: You must specify a repository[/red]")
             raise typer.Exit(code=1)
         repo_url = repo_to_remove.url
 
@@ -204,9 +182,6 @@ def reindex(
             autocompletion=complete_repo_by_url,
         ),
     ] = None,
-    force: bool = typer.Option(
-        default=False, help="Reread FITS headers, even if they are already indexed."
-    ),
 ):
     """
     Reindex a repository by number.
@@ -217,14 +192,12 @@ def reindex(
         repo_to_reindex = repo_url_to_repo(sb, repo_url)
 
         if repo_to_reindex is None:
-            sb.reindex_repos(force=force)
+            sb.reindex_repos()
         else:
             # Get the repo to reindex
             console.print(f"Reindexing repository: {repo_to_reindex.url}")
-            sb.reindex_repo(repo_to_reindex, force=force)
-            console.print(
-                f"[green]Successfully reindexed repository {repo_to_reindex}[/green]"
-            )
+            sb.reindex_repo(repo_to_reindex)
+            console.print(f"[green]Successfully reindexed repository {repo_to_reindex}[/green]")
 
 
 if __name__ == "__main__":