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

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."""

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_list = 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_list:
+        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/process.py

@@ -0,0 +1,154 @@
+"""Processing commands for automated image processing workflows."""
+
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+
+from starbash.app import Starbash, copy_images_to_dir
+from starbash import console
+from starbash.commands.select import selection_by_number
+from starbash.database import SessionRow
+
+app = typer.Typer()
+
+
+@app.command()
+def siril(
+    session_num: Annotated[
+        int,
+        typer.Argument(help="Session number to process (from 'select list' output)"),
+    ],
+    destdir: Annotated[
+        str,
+        typer.Argument(
+            help="Destination directory for Siril directory tree and processing"
+        ),
+    ],
+    run: Annotated[
+        bool,
+        typer.Option(
+            "--run",
+            help="Automatically launch Siril GUI after generating directory tree",
+        ),
+    ] = False,
+):
+    """Generate Siril directory tree and optionally run Siril GUI.
+
+    Creates a properly structured directory tree for Siril processing with
+    biases/, darks/, flats/, and lights/ subdirectories populated with the
+    session's images (via symlinks when possible).
+
+    If --run is specified, launches the Siril GUI with the generated directory
+    structure loaded and ready for processing.
+    """
+    with Starbash("process.siril") as sb:
+        console.print(
+            f"[yellow]Processing session {session_num} for Siril in {destdir}...[/yellow]"
+        )
+
+        # Determine output directory
+        output_dir = Path(destdir)
+
+        # Get the selected session (convert from 1-based to 0-based index)
+        session = selection_by_number(sb, session_num)
+
+        # Get images for this session
+
+        def session_to_dir(src_session: SessionRow, subdir_name: str):
+            """Copy the images from the specified session to the subdir"""
+            img_dir = output_dir / subdir_name
+            img_dir.mkdir(parents=True, exist_ok=True)
+            images = sb.get_session_images(src_session)
+            copy_images_to_dir(images, img_dir)
+
+        # FIXME - pull this dirname from preferences
+        lights = "lights"
+        session_to_dir(session, lights)
+
+        extras = [
+            # FIXME search for BIAS/DARK/FLAT etc... using multiple canonical names
+            ("BIAS", "biases"),
+            ("DARK", "darks"),
+            ("FLAT", "flats"),
+        ]
+        for typ, subdir in extras:
+            candidates = sb.guess_sessions(session, typ)
+            if not candidates:
+                console.print(
+                    f"[yellow]No candidate sessions found for {typ} calibration frames.[/yellow]"
+                )
+            else:
+                session_to_dir(candidates[0], subdir)
+
+        # FIXME put an starbash.toml repo file in output_dir (with info about what we picked/why)
+        # to allow users to override/reprocess with the same settings.
+        # Also FIXME, check for the existence of such a file
+
+
+@app.command()
+def auto(
+    session_num: Annotated[
+        int | None,
+        typer.Argument(
+            help="Session number to process. If not specified, processes all selected sessions."
+        ),
+    ] = None,
+):
+    """Automatic processing with sensible defaults.
+
+    If session number is specified, processes only that session.
+    Otherwise, all currently selected sessions will be processed automatically
+    using the configured recipes and default settings.
+
+    This command handles:
+    - Automatic master frame selection (bias, dark, flat)
+    - Calibration of light frames
+    - Registration and stacking
+    - Basic post-processing
+
+    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]")
+
+        console.print(
+            "[red]Still in development - see https://github.com/geeksville/starbash[/red]"
+        )
+        sb.run_all_stages()
+
+
+@app.command()
+def masters():
+    """Generate master flats, darks, and biases from selected raw frames.
+
+    Analyzes the current selection to find all available calibration frames
+    (BIAS, DARK, FLAT) and automatically generates master calibration frames
+    using stacking recipes.
+
+    Generated master frames are stored in the configured masters directory
+    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()
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context):
+    """Process images using automated workflows.
+
+    These commands handle calibration, registration, stacking, and
+    post-processing of astrophotography sessions.
+    """
+    if ctx.invoked_subcommand is None:
+        # No command provided, show help
+        console.print(ctx.get_help())
+        raise typer.Exit()

starbash/commands/repo.py

@@ -1,99 +1,208 @@
 import typer
 from typing_extensions import Annotated
+from pathlib import Path
+import logging
 
+import starbash
+from repo import repo_suffix, Repo
 from starbash.app import Starbash
-from starbash import console
+from starbash import console, log_filter_level
+from starbash.toml import toml_from_template
 
 app = typer.Typer(invoke_without_command=True)
 
 
-@app.callback()
-def main(
-    ctx: typer.Context,
+def repo_enumeration(sb: Starbash):
+    """return a dict of int (1 based) to Repo instances"""
+    verbose = False  # assume not verbose for enum picking
+    repos = sb.repo_manager.repos if verbose else sb.repo_manager.regular_repos
+
+    return {i + 1: repo for i, repo in enumerate(repos)}
+
+
+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
+    with Starbash("repo.complete.num", stderr_logging=True) as sb:
+        for num, repo in repo_enumeration(sb).items():
+            if str(num).startswith(incomplete):
+                yield (str(num), repo.url)
+
+
+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
+    with Starbash("repo.complete.url", stderr_logging=True) as sb:
+        repos = sb.repo_manager.regular_repos
+
+        for repo in repos:
+            if repo.url.startswith(incomplete):
+                yield (repo.url, f"kind={repo.kind('input')}")
+
+
+@app.command()
+def list(
     verbose: bool = typer.Option(
         False, "--verbose", "-v", help="Show all repos including system repos"
     ),
+):
+    """
+    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
+        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:
+                # No numbers for verbose mode (system repos can't be removed)
+                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 })")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
 ):
     """
     Manage repositories.
 
     When called without a subcommand, lists all repositories.
-    Use --verbose to show all repos including system/recipe repos.
     """
     # If no subcommand is invoked, run the list behavior
     if ctx.invoked_subcommand is None:
-        with Starbash("repo.list") as sb:
-            repos = sb.repo_manager.repos if verbose 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:
-                    # No numbers for verbose mode (system repos can't be removed)
-                    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 })")
+        # No command provided, show help
+        console.print(ctx.get_help())
+        raise typer.Exit()
 
 
 @app.command()
-def add(path: str):
+def add(
+    path: str,
+    master: bool = typer.Option(
+        False, "--master", help="Mark this new repository for master files."
+    ),
+):
     """
     Add a repository. path is either a local path or a remote URL.
     """
+    repo_type = None
+    if master:
+        repo_type = "master"
     with Starbash("repo.add") as sb:
-        repo = sb.user_repo.add_repo_ref(path)
+        p = Path(path)
+
+        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)
+        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}")
+
+        repo = sb.user_repo.add_repo_ref(p)
         if repo:
-            console.print(f"Added repository: {path}")
             sb.reindex_repo(repo)
 
-            # we don't yet write default config files at roots of repos, but it would be easy to add here
+            # 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!!!
 
 
-@app.command()
-def remove(reponum: str):
-    """
-    Remove a repository by number (from list).
-    Use 'starbash repo' to see the repository numbers.
-    """
-    with Starbash("repo.remove") as sb:
-        try:
-            # Parse the repo number (1-indexed)
-            repo_index = int(reponum) - 1
+def repo_url_to_repo(sb: Starbash, repo_url: str | None) -> Repo | None:
+    """Helper to get a Repo instance from a URL or number"""
+    if repo_url is None:
+        return None
 
-            # Get only the regular (user-visible) repos
-            regular_repos = sb.repo_manager.regular_repos
-
-            if repo_index < 0 or repo_index >= len(regular_repos):
-                console.print(
-                    f"[red]Error: Repository number {reponum} is out of range. Valid range: 1-{len(regular_repos)}[/red]"
-                )
-                raise typer.Exit(code=1)
+    # try to find by URL
+    repo = sb.repo_manager.get_repo_by_url(repo_url)
+    if repo is not None:
+        return repo
 
-            # Get the repo to remove
-            repo_to_remove = regular_repos[repo_index]
-            repo_url = repo_to_remove.url
+    # Fall back to finding by number
+    try:
+        # Parse the repo number (1-indexed)
+        repo_index = int(repo_url) - 1
 
-            # Remove the repo reference from user config
-            sb.remove_repo_ref(repo_url)
-            console.print(f"[green]Removed repository: {repo_url}[/green]")
+        # Get only the regular (user-visible) repos
+        regular_repos = sb.repo_manager.regular_repos
 
-        except ValueError:
+        if repo_index < 0 or repo_index >= len(regular_repos):
             console.print(
-                f"[red]Error: '{reponum}' is not a valid repository number. Please use a number from 'repo list'.[/red]"
+                f"[red]Error: '{repo_url}' is not a valid repository number.  Please enter a repository number or URL.[/red]"
             )
             raise typer.Exit(code=1)
 
+        return regular_repos[repo_index]
+    except ValueError:
+        console.print(
+            f"[red]Error: '{repo_url}' is not valid.  Please enter a repository number or URL.[/red]"
+        )
+        raise typer.Exit(code=1)
+
 
 @app.command()
-def reindex(
+def remove(
     reponum: Annotated[
+        str,
+        typer.Argument(
+            help="Repository number or URL", autocompletion=complete_repo_by_url
+        ),
+    ],
+):
+    """
+    Remove a repository by number (from list).
+    Use 'starbash repo' to see the repository numbers.
+    """
+    with Starbash("repo.remove") as sb:
+        # 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]")
+            raise typer.Exit(code=1)
+        repo_url = repo_to_remove.url
+
+        # Remove the repo reference from user config
+        sb.remove_repo_ref(repo_url)
+        console.print(f"[green]Removed repository: {repo_url}[/green]")
+
+
+@app.command()
+def reindex(
+    repo_url: Annotated[
         str | None,
-        typer.Argument(help="The repository number, if not specified reindex all."),
+        typer.Argument(
+            help="The repository URL, if not specified reindex all.",
+            autocompletion=complete_repo_by_url,
+        ),
     ] = None,
     force: bool = typer.Option(
         default=False, help="Reread FITS headers, even if they are already indexed."
@@ -105,35 +214,17 @@ def reindex(
     Use 'starbash repo' to see the repository numbers.
     """
     with Starbash("repo.reindex") as sb:
-        if reponum is None:
+        repo_to_reindex = repo_url_to_repo(sb, repo_url)
+
+        if repo_to_reindex is None:
             sb.reindex_repos(force=force)
         else:
-            try:
-                # Parse the repo number (1-indexed)
-                repo_index = int(reponum) - 1
-
-                # Get only the regular (user-visible) repos
-                regular_repos = sb.repo_manager.regular_repos
-
-                if repo_index < 0 or repo_index >= len(regular_repos):
-                    console.print(
-                        f"[red]Error: Repository number {reponum} is out of range. Valid range: 1-{len(regular_repos)}[/red]"
-                    )
-                    raise typer.Exit(code=1)
-
-                # Get the repo to reindex
-                repo_to_reindex = regular_repos[repo_index]
-                console.print(f"Reindexing repository: {repo_to_reindex.url}")
-                sb.reindex_repo(repo_to_reindex, force=force)
-                console.print(
-                    f"[green]Successfully reindexed repository {reponum}[/green]"
-                )
-
-            except ValueError:
-                console.print(
-                    f"[red]Error: '{reponum}' is not a valid repository number. Please use a number from 'starbash repo'.[/red]"
-                )
-                raise typer.Exit(code=1)
+            # 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]"
+            )
 
 
 if __name__ == "__main__":