starbash 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

starbash/commands/__init__.py

@@ -20,20 +20,3 @@ 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

@@ -27,7 +27,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]]
@@ -38,7 +38,7 @@ def dump_column(sb: Starbash, human_name: str, column_name: str) -> None:
     all_counts = Counter(allfound)
 
     # Sort by telescope name
-    sorted_telescopes = sorted(found_counts.items())
+    sorted_list = sorted(found_counts.items())
 
     # Create and display table
     table = Table(
@@ -49,7 +49,7 @@ def dump_column(sb: Starbash, human_name: str, column_name: str) -> None:
         "# of sessions", style=TABLE_COLUMN_STYLE, no_wrap=True, justify="right"
     )
 
-    for i, count in sorted_telescopes:
+    for i, count in sorted_list:
         table.add_row(i, str(count))
 
     console.print(table)
@@ -76,6 +76,75 @@ 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:
+        # 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)
+        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) or "Unknown"
+            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.

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,224 @@
 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.paths import get_user_documents_dir
+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: 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.
     """
+    repo_type = None
+    if master:
+        repo_type = "master"
+    elif processed:
+        repo_type = "processed"
+
+    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:
+            console.print("[red]Error: path is required for input repositories[/red]")
+            raise typer.Exit(1)
+
     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_{session_config}.fit",
+                    },
+                )
+            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 +230,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__":