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

starbash/commands/select.py

@@ -1,32 +1,30 @@
 """Selection commands for filtering sessions and targets."""
 
-import os
-from typing import Any
+import logging
 from collections import Counter
-import typer
 from pathlib import Path
-from typing_extensions import Annotated
+from typing import Annotated, Any
+
+import typer
 from rich.table import Table
-import logging
 
 import starbash
-from starbash import to_shortdate
+from starbash import console, to_shortdate
 from starbash.app import Starbash, copy_images_to_dir
-from starbash.database import Database, SessionRow, get_column_name
-from starbash import console
 from starbash.commands import (
-    format_duration,
     TABLE_COLUMN_STYLE,
+    TABLE_HEADER_STYLE,
     TABLE_VALUE_STYLE,
+    format_duration,
 )
+from starbash.database import Database, SessionRow, get_column_name
 
 app = typer.Typer()
 
 
 def get_column(sb: Starbash, column_name: str) -> Counter:
-
     # 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)
     allfound = [session[column_name] for session in allsessions if session[column_name]]
@@ -43,9 +41,7 @@ def complete_date(incomplete: str, column_name: str):
     in the returned str->count, just include the date portion (YYYY-MM-DD)."""
 
     # 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("select.complete.date", stderr_logging=True) as sb:
         c = get_column(sb, column_name)
 
@@ -64,9 +60,7 @@ def complete_date(incomplete: str, column_name: str):
 
 def complete_column(incomplete: str, column_name: 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.column", stderr_logging=True) as sb:
         c = get_column(sb, column_name)
 
@@ -81,6 +75,7 @@ def clear():
     with Starbash("selection.clear") as sb:
         sb.selection.clear()
         console.print("[green]Selection cleared - now selecting all sessions[/green]")
+        do_list_sessions(sb, brief=not starbash.verbose_output)
 
 
 @app.command()
@@ -89,9 +84,7 @@ def target(
         str,
         typer.Argument(
             help="Target name to add to the selection (e.g., 'M31', 'NGC 7000')",
-            autocompletion=lambda incomplete: complete_column(
-                incomplete, Database.OBJECT_KEY
-            ),
+            autocompletion=lambda incomplete: complete_column(incomplete, Database.OBJECT_KEY),
         ),
     ],
 ):
@@ -102,6 +95,7 @@ def target(
         sb.selection.targets = []
         sb.selection.add_target(target_name)
         console.print(f"[green]Selection limited to target: {target_name}[/green]")
+        do_list_sessions(sb, brief=not starbash.verbose_output)
 
 
 @app.command()
@@ -110,9 +104,7 @@ def telescope(
         str,
         typer.Argument(
             help="Telescope name to add to the selection (e.g., 'Vespera', 'EdgeHD 8')",
-            autocompletion=lambda incomplete: complete_column(
-                incomplete, Database.TELESCOP_KEY
-            ),
+            autocompletion=lambda incomplete: complete_column(incomplete, Database.TELESCOP_KEY),
         ),
     ],
 ):
@@ -122,9 +114,8 @@ def telescope(
         # In the future, we could support adding multiple telescopes
         sb.selection.telescopes = []
         sb.selection.add_telescope(telescope_name)
-        console.print(
-            f"[green]Selection limited to telescope: {telescope_name}[/green]"
-        )
+        console.print(f"[green]Selection limited to telescope: {telescope_name}[/green]")
+        do_list_sessions(sb, brief=not starbash.verbose_output)
 
 
 def complete_name(incomplete: str, names: list[str]):
@@ -149,18 +140,14 @@ def date(
         str,
         typer.Argument(
             help="Date in ISO format (YYYY-MM-DD) or two dates separated by space for 'between'",
-            autocompletion=lambda incomplete: complete_date(
-                incomplete, Database.START_KEY
-            ),
+            autocompletion=lambda incomplete: complete_date(incomplete, Database.START_KEY),
         ),
     ],
     end_date: Annotated[
         str | None,
         typer.Argument(
             help="End date for 'between' operation (YYYY-MM-DD)",
-            autocompletion=lambda incomplete: complete_date(
-                incomplete, Database.START_KEY
-            ),
+            autocompletion=lambda incomplete: complete_date(incomplete, Database.START_KEY),
         ),
     ] = None,
 ):
@@ -176,19 +163,13 @@ def date(
 
         if operation == "after":
             sb.selection.set_date_range(start=date_value, end=None)
-            console.print(
-                f"[green]Selection limited to sessions after {date_value}[/green]"
-            )
+            console.print(f"[green]Selection limited to sessions after {date_value}[/green]")
         elif operation == "before":
             sb.selection.set_date_range(start=None, end=date_value)
-            console.print(
-                f"[green]Selection limited to sessions before {date_value}[/green]"
-            )
+            console.print(f"[green]Selection limited to sessions before {date_value}[/green]")
         elif operation == "between":
             if not end_date:
-                console.print(
-                    "[red]Error: 'between' operation requires two dates[/red]"
-                )
+                console.print("[red]Error: 'between' operation requires two dates[/red]")
                 raise typer.Exit(1)
             sb.selection.set_date_range(start=date_value, end=end_date)
             console.print(
@@ -200,90 +181,91 @@ def date(
             )
             raise typer.Exit(1)
 
+        do_list_sessions(sb, brief=not starbash.verbose_output)
 
-@app.command(name="list")
-def list_sessions(
-    verbose: bool = typer.Option(
-        False,
-        "--verbose",
-        "-v",
-        help="Show all sessions (normally Dark/Bias/Flat are hidden)",
-    )
-):
-    """List sessions (filtered based on the current selection)"""
 
-    with Starbash("selection.list") as sb:
-        sessions = sb.search_session()
-        if sessions and isinstance(sessions, list):
-            len_all = sb.db.len_table(Database.SESSIONS_TABLE)
-            table = Table(title=f"Sessions ({len(sessions)} selected out of {len_all})")
-            sb.analytics.set_data("session.num_selected", len(sessions))
-            sb.analytics.set_data("session.num_total", len_all)
-
-            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=TABLE_COLUMN_STYLE, no_wrap=True
-            )  # type of frames, filter, target
-
-            total_images = 0
-            total_seconds = 0.0
-            filters = set()
-            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 = get_key(Database.START_KEY)
-                date = to_shortdate(date_iso)
-
-                object = get_key(Database.OBJECT_KEY)
-                filter = get_key(Database.FILTER_KEY)
-                filters.add(filter)
-                image_type = get_key(Database.IMAGETYP_KEY)
-                image_types.add(image_type)
-                telescope = get_key(Database.TELESCOP_KEY)
-                telescopes.add(telescope)
-
-                # Show the non normalized target name
-                metadata = sess.get("metadata")
-                if metadata:
-                    long_name = metadata.get("OBJECT")
-                    if long_name:
-                        object = long_name
-
-                # Format total exposure time as integer seconds
-                exptime_raw = get_key(Database.EXPTIME_TOTAL_KEY)
-                try:
-                    exptime_float = float(exptime_raw)
-                    total_seconds += exptime_float
-                    total_secs = format_duration(int(exptime_float))
-                except (ValueError, TypeError):
-                    total_secs = exptime_raw
-
-                # Count images
-                try:
-                    num_images = int(get_key(Database.NUM_IMAGES_KEY, 0))
-                    total_images += num_images
-                except (ValueError, TypeError):
-                    num_images = get_key(Database.NUM_IMAGES_KEY)
-
-                type_str = image_type
-                if image_type.upper() == "LIGHT":
-                    image_type = filter
-                elif image_type.upper() == "FLAT":
-                    image_type = f"{image_type}/{filter}"
-                else:  # either bias or dark
-                    object = ""  # Don't show meaningless target
+def do_list_sessions(sb: Starbash, brief: bool = False):
+    """List sessions (filtered based on the current selection)"""
 
+    sessions = sb.search_session()
+    if sessions and isinstance(sessions, list):
+        len_all = sb.db.len_table(Database.SESSIONS_TABLE)
+        table = Table(
+            title=f"Sessions ({len(sessions)} selected out of {len_all})",
+            header_style=TABLE_HEADER_STYLE,
+        )
+        sb.analytics.set_data("session.num_selected", len(sessions))
+        sb.analytics.set_data("session.num_total", len_all)
+
+        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=TABLE_COLUMN_STYLE, no_wrap=True
+        )  # type of frames, filter, target
+
+        total_images = 0
+        total_seconds = 0.0
+        filters = set()
+        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)
+
+        brief_max_rows = 10
+        for session_index, sess in enumerate(sessions):
+            date_iso = get_key(Database.START_KEY)
+            date = to_shortdate(date_iso)
+
+            object = get_key(Database.OBJECT_KEY)
+            filter = get_key(Database.FILTER_KEY)
+            filters.add(filter)
+            image_type = get_key(Database.IMAGETYP_KEY)
+            image_types.add(image_type)
+            telescope = get_key(Database.TELESCOP_KEY)
+            telescopes.add(telescope)
+
+            # Show the non normalized target name
+            metadata = sess.get("metadata")
+            if metadata:
+                long_name = metadata.get("OBJECT")
+                if long_name:
+                    object = long_name
+
+            # Format total exposure time as integer seconds
+            exptime_raw = get_key(Database.EXPTIME_TOTAL_KEY)
+            try:
+                exptime_float = float(exptime_raw)
+                total_seconds += exptime_float
+                total_secs = format_duration(int(exptime_float))
+            except (ValueError, TypeError):
+                total_secs = exptime_raw
+
+            # Count images
+            try:
+                num_images = int(get_key(Database.NUM_IMAGES_KEY, 0))
+                total_images += num_images
+            except (ValueError, TypeError):
+                num_images = get_key(Database.NUM_IMAGES_KEY)
+
+            if image_type.upper() == "LIGHT":
+                image_type = filter
+            elif image_type.upper() == "FLAT":
+                image_type = f"{image_type}/{filter}"
+            else:  # either bias or dark
+                object = ""  # Don't show meaningless target
+
+            if brief and session_index == brief_max_rows:
+                table.add_row("...", "...", "...", "...", "...", "...", "...")
+            elif brief and session_index > brief_max_rows:
+                pass  # Show nothing
+            else:
                 table.add_row(
                     str(session_index + 1),
                     date,
@@ -294,27 +276,41 @@ def list_sessions(
                     object,
                 )
 
-            # Add totals row
-            if sessions:
-                table.add_row(
-                    "",
-                    "",
-                    f"[bold]{total_images}[/bold]",
-                    f"[bold]{format_duration(int(total_seconds))}[/bold]",
-                    "",
-                    "",
-                    "",
-                )
+        # Add totals row
+        if sessions:
+            table.add_row(
+                "",
+                "",
+                f"[bold]{total_images}[/bold]",
+                f"[bold]{format_duration(int(total_seconds))}[/bold]",
+                "",
+                "",
+                "",
+            )
 
-            console.print(table)
+        console.print(table)
 
-            # FIXME - move these analytics elsewhere so they can be reused when search_session()
-            # is used to generate processing lists.
-            sb.analytics.set_data("session.total_images", total_images)
-            sb.analytics.set_data("session.total_exposure_seconds", int(total_seconds))
-            sb.analytics.set_data("session.telescopes", telescopes)
-            sb.analytics.set_data("session.filters", filters)
-            sb.analytics.set_data("session.image_types", image_types)
+        # FIXME - move these analytics elsewhere so they can be reused when search_session()
+        # is used to generate processing lists.
+        sb.analytics.set_data("session.total_images", total_images)
+        sb.analytics.set_data("session.total_exposure_seconds", int(total_seconds))
+        sb.analytics.set_data("session.telescopes", telescopes)
+        sb.analytics.set_data("session.filters", filters)
+        sb.analytics.set_data("session.image_types", image_types)
+
+
+@app.command(name="list")
+def list_sessions(
+    brief: bool = typer.Option(
+        False,
+        "--brief",
+        help="If there are many sessions, show only a few.",
+    ),
+):
+    """List sessions (filtered based on the current selection)"""
+
+    with Starbash("selection.list") as sb:
+        do_list_sessions(sb, brief=brief)
 
 
 def selection_by_number(
@@ -351,9 +347,7 @@ def export(
     ],
     destdir: Annotated[
         str,
-        typer.Argument(
-            help="Directory path to export to (if it doesn't exist it will be created)"
-        ),
+        typer.Argument(help="Directory path to export to (if it doesn't exist it will be created)"),
     ],
 ):
     """Export the images for the indicated session number.
@@ -368,9 +362,7 @@ def export(
         # Get images for this session
         images = sb.get_session_images(session)
         if not images:
-            console.print(
-                f"[red]Error: No images found for session {session_num}.[/red]"
-            )
+            console.print(f"[red]Error: No images found for session {session_num}.[/red]")
             raise typer.Exit(0)
 
         # Determine output directory
@@ -395,7 +387,7 @@ def show_selection(ctx: typer.Context):
             if summary["status"] == "all":
                 console.print(f"[yellow]{summary['message']}[/yellow]")
             else:
-                table = Table(title="Current Selection")
+                table = Table(title="Current Selection", header_style=TABLE_HEADER_STYLE)
                 table.add_column("Criteria", style=TABLE_COLUMN_STYLE)
                 table.add_column("Value", style=TABLE_VALUE_STYLE)
 

starbash/commands/user.py

@@ -1,9 +1,12 @@
+from textwrap import dedent
+from typing import Annotated
+
 import typer
-from typing_extensions import Annotated
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
 
 from starbash.app import Starbash
-from starbash import console
-from rich.panel import Panel
+from starbash.paths import get_user_documents_dir
 
 app = typer.Typer()
 
@@ -21,6 +24,8 @@ def analytics(
     Enable or disable analytics (crash reports and usage data).
     """
     with Starbash("analytics.change") as sb:
+        from starbash import console
+
         sb.analytics.set_data("analytics.enabled", enable)
         sb.user_repo.set("analytics.enabled", enable)
         sb.user_repo.write_config()
@@ -41,6 +46,8 @@ def name(
     Set your name for attribution in generated images.
     """
     with Starbash("user.name") as sb:
+        from starbash import console
+
         sb.user_repo.set("user.name", user_name)
         sb.user_repo.write_config()
         console.print(f"User name set to: {user_name}")
@@ -59,27 +66,46 @@ def email(
     Set your email for attribution in generated images.
     """
     with Starbash("user.email") as sb:
+        from starbash import console
+
         sb.user_repo.set("user.email", user_email)
         sb.user_repo.write_config()
         console.print(f"User email set to: {user_email}")
 
 
-def do_reinit(sb: Starbash) -> None:
-    console.print()
-    console.print(
-        Panel.fit(
-            "[bold cyan]Starbash getting started...[/bold cyan]\n\n"
-            "Let's set up your preferences. You can skip any question by pressing Enter.",
-            border_style="cyan",
+def _ask_masters(sb: Starbash) -> None:
+    from starbash import console
+
+    has_masters = sb.repo_manager.get_repo_by_kind("master") is not None
+    if not has_masters:
+        want_default_dirs = Confirm.ask(
+            dedent("""
+            Would you like to create default output directories in your Documents folder
+            (recommended - you can change this later with [cyan]'sb repo ...'[/cyan])?
+            """),
+            default=True,
+            console=console,
         )
-    )
-    console.print()
+        if want_default_dirs:
+            console.print("Creating default repositories...")
+            master_path = str(get_user_documents_dir() / "repos" / "master")
+            processed_path = str(get_user_documents_dir() / "repos" / "processed")
+            sb.add_local_repo(path=master_path, repo_type="master")
+            sb.add_local_repo(path=processed_path, repo_type="processed")
+            console.print(f"✅ Created master repository at: {master_path}")
+            console.print(f"✅ Created processed repository at: {processed_path}")
+            console.print()
+
+
+def _ask_user_config(sb: Starbash) -> None:
+    from starbash import console
 
     # Ask for username
-    user_name = typer.prompt(
+    user_name = Prompt.ask(
         "Enter your name (for attribution in generated images)",
-        default="",
+        default=sb.user_repo.get("user.name", ""),
         show_default=False,
+        console=console,
     )
     sb.analytics.set_data("analytics.use_name", user_name != "")
     if user_name:
@@ -89,10 +115,11 @@ def do_reinit(sb: Starbash) -> None:
         console.print("[dim]Skipped name[/dim]")
 
     # Ask for email
-    user_email = typer.prompt(
+    user_email = Prompt.ask(
         "Enter your email address (for attribution in generated images)",
-        default="",
+        default=sb.user_repo.get("user.email", ""),
         show_default=False,
+        console=console,
     )
     sb.analytics.set_data("analytics.use_email", user_email != "")
     if user_email:
@@ -102,10 +129,11 @@ def do_reinit(sb: Starbash) -> None:
         console.print("[dim]Skipped email[/dim]")
 
     # Ask about including email in crash reports
-    include_in_reports = typer.confirm(
-        "Would you like to include your email address with crash reports/analytics? "
+    include_in_reports = Confirm.ask(
+        "Would you like to include your email address with crash reports/analytics?\n"
         "(This helps us follow up if we need more information about issues.)",
-        default=False,
+        default=sb.user_repo.get("analytics.include_user", False),
+        console=console,
     )
     sb.analytics.set_data("analytics.use_email_report", include_in_reports)
     sb.user_repo.set("analytics.include_user", include_in_reports)
@@ -118,24 +146,59 @@ def do_reinit(sb: Starbash) -> None:
     # Save all changes
     sb.user_repo.write_config()
 
+
+def do_reinit(sb: Starbash) -> None:
+    from starbash import console
+
+    console.print()
     console.print(
         Panel.fit(
-            "[bold green]Configuration complete![/bold green]\n\n"
-            "Your preferences have been saved.",
+            "[bold cyan]Starbash getting started...[/bold cyan]\n\n"
+            "Let's do your first time setup.  You can skip any question by pressing Enter.\n"
+            "If you need to re-run this setup later, just run: [cyan]'sb user setup'[/cyan]",
+            border_style="cyan",
+        )
+    )
+    console.print()
+    console.print()
+    _ask_user_config(sb)
+    _ask_masters(sb)
+
+    console.print(
+        Panel.fit(
+            dedent("""
+            [bold green]Basic setup is complete[/bold green]
+            You are almost ready to start using Starbash!
+
+            Recommended next steps (to get your first auto-generated images):
+            1. Add your source raw image repositories (starbash will only READ from these):
+               [cyan]sb repo add /path/to/your/raw_images[/cyan]
+            2. Ask starbash to auto-generate 'master' darks, biases and flats:
+                [cyan]sb process masters[/cyan]
+            3. Process your images using automated workflows:
+                [cyan]sb process auto[/cyan]
+            4. (Highly recommended) Tell your shell to auto-complete starbash commands:
+                [cyan]sb shell-complete --install-completion[/cyan]
+
+            This project is currently very 'alpha' but we are eager to have it work for you.
+            For full instructions and support [link=https://github.com/geeksville/starbash]visit our github[/link].
+            If you find problems or have questions, just open an issue and we'll work with you.
+            """),
             border_style="green",
+            title="Almost done!",
         )
     )
 
 
 @app.command()
-def reinit():
+def setup():
     """
     Configure starbash via a brief guided process.
 
     This will ask you for your name, email, and analytics preferences.
     You can skip any question by pressing Enter.
     """
-    with Starbash("user.reinit") as sb:
+    with Starbash("user.setup") as sb:
         do_reinit(sb)
 
 
@@ -143,6 +206,8 @@ def reinit():
 def main_callback(ctx: typer.Context):
     """Main callback for the Starbash application."""
     if ctx.invoked_subcommand is None:
+        from starbash import console
+
         # No command provided, show help
         console.print(ctx.get_help())
         raise typer.Exit()