starbash 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

starbash/commands/select.py

@@ -0,0 +1,326 @@
+"""Selection commands for filtering sessions and targets."""
+
+import os
+import typer
+from pathlib import Path
+from typing_extensions import Annotated
+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 import console
+
+app = typer.Typer()
+
+
+@app.command(name="any")
+def clear():
+    """Remove any filters on sessions, etc... (select everything)."""
+    with Starbash("selection.clear") as sb:
+        sb.selection.clear()
+        console.print("[green]Selection cleared - now selecting all sessions[/green]")
+
+
+@app.command()
+def target(
+    target_name: Annotated[
+        str,
+        typer.Argument(
+            help="Target name to add to the selection (e.g., 'M31', 'NGC 7000')"
+        ),
+    ],
+):
+    """Limit the current selection to only the named target."""
+    with Starbash("selection.target") as sb:
+        # For now, replace existing targets with this one
+        # In the future, we could support adding multiple targets
+        sb.selection.targets = []
+        sb.selection.add_target(target_name)
+        console.print(f"[green]Selection limited to target: {target_name}[/green]")
+
+
+@app.command()
+def telescope(
+    telescope_name: Annotated[
+        str,
+        typer.Argument(
+            help="Telescope name to add to the selection (e.g., 'Vespera', 'EdgeHD 8')"
+        ),
+    ],
+):
+    """Limit the current selection to only the named telescope."""
+    with Starbash("selection.telescope") as sb:
+        # For now, replace existing telescopes with this one
+        # 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]"
+        )
+
+
+@app.command()
+def date(
+    operation: Annotated[
+        str,
+        typer.Argument(help="Date operation: 'after', 'before', or 'between'"),
+    ],
+    date_value: Annotated[
+        str,
+        typer.Argument(
+            help="Date in ISO format (YYYY-MM-DD) or two dates separated by space for 'between'"
+        ),
+    ],
+    end_date: Annotated[
+        str | None,
+        typer.Argument(help="End date for 'between' operation (YYYY-MM-DD)"),
+    ] = None,
+):
+    """Limit to sessions in the specified date range.
+
+    Examples:
+        starbash selection date after 2023-10-01
+        starbash selection date before 2023-12-31
+        starbash selection date between 2023-10-01 2023-12-31
+    """
+    with Starbash("selection.date") as sb:
+        operation = operation.lower()
+
+        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]"
+            )
+        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]"
+            )
+        elif operation == "between":
+            if not end_date:
+                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(
+                f"[green]Selection limited to sessions between {date_value} and {end_date}[/green]"
+            )
+        else:
+            console.print(
+                f"[red]Error: Unknown operation '{operation}'. Use 'after', 'before', or 'between'[/red]"
+            )
+            raise typer.Exit(1)
+
+
+def format_duration(seconds: int):
+    """Format seconds as a human-readable duration string."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 120:
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s" if secs else f"{minutes}m"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return f"{hours}h {minutes}m" if minutes else f"{hours}h"
+
+
+@app.command(name="list")
+def list_sessions():
+    """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_session()
+            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="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(
+                "About", style="cyan", no_wrap=True
+            )  # type of frames, filter, target
+
+            total_images = 0
+            total_seconds = 0.0
+            filters = set()
+            image_types = set()
+            telescopes = set()
+
+            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
+
+                object = str(sess.get(Database.OBJECT_KEY, "N/A"))
+                filter = sess.get(Database.FILTER_KEY, "N/A")
+                filters.add(filter)
+                image_type = str(sess.get(Database.IMAGETYP_KEY, "N/A"))
+                image_types.add(image_type)
+                telescope = str(sess.get(Database.TELESCOP_KEY, "N/A"))
+                telescopes.add(telescope)
+
+                # Format total exposure time as integer seconds
+                exptime_raw = str(sess.get(Database.EXPTIME_TOTAL_KEY, "N/A"))
+                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(sess.get(Database.NUM_IMAGES_KEY, 0))
+                    total_images += num_images
+                except (ValueError, TypeError):
+                    num_images = sess.get(Database.NUM_IMAGES_KEY, "N/A")
+
+                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
+
+                table.add_row(
+                    str(session_index + 1),
+                    date,
+                    str(num_images),
+                    total_secs,
+                    image_type,
+                    telescope,
+                    object,
+                )
+
+            # Add totals row
+            if sessions:
+                table.add_row(
+                    "",
+                    "",
+                    f"[bold]{total_images}[/bold]",
+                    f"[bold]{format_duration(int(total_seconds))}[/bold]",
+                    "",
+                    "",
+                    "",
+                )
+
+            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)
+
+
+@app.command()
+def export(
+    session_num: Annotated[
+        int,
+        typer.Argument(help="Session number to export (from 'select list' output)"),
+    ],
+    destdir: Annotated[
+        str,
+        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.
+
+    Uses symbolic links when possible, otherwise copies files.
+    The session number corresponds to the '#' column in 'select list' output.
+    """
+    with Starbash("selection.export") as sb:
+        # Get the filtered sessions
+        sessions = sb.search_session()
+
+        if not sessions or not isinstance(sessions, list):
+            console.print(
+                "[red]No sessions found. Check your selection criteria.[/red]"
+            )
+            raise typer.Exit(1)
+
+        # Validate session number
+        if session_num < 1 or session_num > len(sessions):
+            console.print(
+                f"[red]Error: Session number {session_num} is out of range. "
+                f"Valid range is 1-{len(sessions)}.[/red]"
+            )
+            console.print(
+                "[yellow]Use 'select list' to see available sessions.[/yellow]"
+            )
+            raise typer.Exit(1)
+
+        # Get the selected session (convert from 1-based to 0-based index)
+        session = sessions[session_num - 1]
+
+        # Get the session's database row ID
+        session_id = session.get("id")
+        if session_id is None:
+            console.print(
+                f"[red]Error: Could not find session ID for session {session_num}.[/red]"
+            )
+            raise typer.Exit(1)
+
+        # Determine output directory
+        output_dir = Path(destdir)
+
+        # Create output directory if it doesn't exist
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Get images for this session
+        images = sb.get_session_images(session_id)
+
+        if not images:
+            console.print(
+                f"[yellow]Warning: No images found for session {session_num}.[/yellow]"
+            )
+            raise typer.Exit(0)
+
+        copy_images_to_dir(images, output_dir)
+
+
+@app.callback(invoke_without_command=True)
+def show_selection(ctx: typer.Context):
+    """List information about the current selection.
+
+    This is the default command when no subcommand is specified.
+    """
+    if ctx.invoked_subcommand is None:
+        with Starbash("selection.show") as sb:
+            summary = sb.selection.summary()
+
+            if summary["status"] == "all":
+                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")
+
+                for criterion in summary["criteria"]:
+                    parts = criterion.split(": ", 1)
+                    if len(parts) == 2:
+                        table.add_row(parts[0], parts[1])
+                    else:
+                        table.add_row(criterion, "")
+
+                console.print(table)

starbash/commands/user.py

@@ -3,6 +3,7 @@ from typing_extensions import Annotated
 
 from starbash.app import Starbash
 from starbash import console
+from rich.panel import Panel
 
 app = typer.Typer()
 
@@ -19,9 +20,9 @@ def analytics(
     """
     Enable or disable analytics (crash reports and usage data).
     """
-    with Starbash("analytics-enable") as sb:
+    with Starbash("analytics.change") as sb:
         sb.analytics.set_data("analytics.enabled", enable)
-        sb.user_repo.config["analytics.enabled"] = enable
+        sb.user_repo.set("analytics.enabled", enable)
         sb.user_repo.write_config()
         status = "enabled" if enable else "disabled"
         console.print(f"Analytics (crash reports) {status}.")
@@ -39,8 +40,8 @@ def name(
     """
     Set your name for attribution in generated images.
     """
-    with Starbash("user-name") as sb:
-        sb.user_repo.config["user.name"] = user_name
+    with Starbash("user.name") as sb:
+        sb.user_repo.set("user.name", user_name)
         sb.user_repo.write_config()
         console.print(f"User name set to: {user_name}")
 
@@ -57,7 +58,91 @@ def email(
     """
     Set your email for attribution in generated images.
     """
-    with Starbash("user-email") as sb:
-        sb.user_repo.config["user.email"] = user_email
+    with Starbash("user.email") as sb:
+        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",
+        )
+    )
+    console.print()
+
+    # Ask for username
+    user_name = typer.prompt(
+        "Enter your name (for attribution in generated images)",
+        default="",
+        show_default=False,
+    )
+    sb.analytics.set_data("analytics.use_name", user_name != "")
+    if user_name:
+        sb.user_repo.set("user.name", user_name)
+        console.print(f"✅ Name set to: {user_name}")
+    else:
+        console.print("[dim]Skipped name[/dim]")
+
+    # Ask for email
+    user_email = typer.prompt(
+        "Enter your email address (for attribution in generated images)",
+        default="",
+        show_default=False,
+    )
+    sb.analytics.set_data("analytics.use_email", user_email != "")
+    if user_email:
+        sb.user_repo.set("user.email", user_email)
+        console.print(f"✅ Email set to: {user_email}")
+    else:
+        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? "
+        "(This helps us follow up if we need more information about issues.)",
+        default=False,
+    )
+    sb.analytics.set_data("analytics.use_email_report", include_in_reports)
+    sb.user_repo.set("analytics.include_user", include_in_reports)
+    if include_in_reports:
+        console.print("✅ Email will be included with crash reports")
+    else:
+        console.print("❌ Email will NOT be included with crash reports")
+    console.print()
+
+    # Save all changes
+    sb.user_repo.write_config()
+
+    console.print(
+        Panel.fit(
+            "[bold green]Configuration complete![/bold green]\n\n"
+            "Your preferences have been saved.",
+            border_style="green",
+        )
+    )
+
+
+@app.command()
+def reinit():
+    """
+    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:
+        do_reinit(sb)
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context):
+    """Main callback for the Starbash application."""
+    if ctx.invoked_subcommand is None:
+        # No command provided, show help
+        console.print(ctx.get_help())
+        raise typer.Exit()