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

starbash/commands/select.py

@@ -1,20 +1,80 @@
 """Selection commands for filtering sessions and targets."""
 
 import os
+from typing import Any
+from collections import Counter
 import typer
 from pathlib import Path
 from typing_extensions import Annotated
-from datetime import datetime
 from rich.table import Table
+import logging
 
+import starbash
+from starbash import to_shortdate
 from starbash.app import Starbash, copy_images_to_dir
-from starbash.database import Database
+from starbash.database import Database, SessionRow, get_column_name
 from starbash import console
-from starbash.commands import format_duration
+from starbash.commands import (
+    format_duration,
+    TABLE_COLUMN_STYLE,
+    TABLE_VALUE_STYLE,
+)
 
 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(("", []))
+
+    column_name = get_column_name(column_name)
+    allfound = [session[column_name] for session in allsessions if session[column_name]]
+
+    # Count occurrences of each telescope
+    all_counts = Counter(allfound)
+
+    return all_counts
+
+
+def complete_date(incomplete: str, column_name: str):
+    """calls get_column() and assumes the returned str->count object has iso datetime strings as the keys
+    it merges the counts for all dates that are on the same local timezone day.
+    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
+    with Starbash("select.complete.date", stderr_logging=True) as sb:
+        c = get_column(sb, column_name)
+
+        # Merge counts by date (YYYY-MM-DD) in local timezone
+        date_counts = Counter()
+        for datetime_str, count in c.items():
+            # Extract just the date portion (YYYY-MM-DD) from local datetime
+            date_only = to_shortdate(datetime_str)
+            date_counts[date_only] += count
+
+        # Yield completions matching the incomplete input
+        for date, count in sorted(date_counts.items(), reverse=True):
+            if date.startswith(incomplete):
+                yield (date, f"{count} sessions")
+
+
+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
+    with Starbash("repo.complete.column", stderr_logging=True) as sb:
+        c = get_column(sb, column_name)
+
+        for item, count in c.items():
+            if item.startswith(incomplete):
+                yield (item, f"{count} sessions")
+
+
 @app.command(name="any")
 def clear():
     """Remove any filters on sessions, etc... (select everything)."""
@@ -28,7 +88,10 @@ def target(
     target_name: Annotated[
         str,
         typer.Argument(
-            help="Target name to add to the selection (e.g., 'M31', 'NGC 7000')"
+            help="Target name to add to the selection (e.g., 'M31', 'NGC 7000')",
+            autocompletion=lambda incomplete: complete_column(
+                incomplete, Database.OBJECT_KEY
+            ),
         ),
     ],
 ):
@@ -46,7 +109,10 @@ def telescope(
     telescope_name: Annotated[
         str,
         typer.Argument(
-            help="Telescope name to add to the selection (e.g., 'Vespera', 'EdgeHD 8')"
+            help="Telescope name to add to the selection (e.g., 'Vespera', 'EdgeHD 8')",
+            autocompletion=lambda incomplete: complete_column(
+                incomplete, Database.TELESCOP_KEY
+            ),
         ),
     ],
 ):
@@ -61,21 +127,41 @@ def telescope(
         )
 
 
+def complete_name(incomplete: str, names: list[str]):
+    """Return typer style autocompletion from a list of string constants."""
+    for name in names:
+        if name.startswith(incomplete):
+            yield name
+
+
 @app.command()
 def date(
     operation: Annotated[
         str,
-        typer.Argument(help="Date operation: 'after', 'before', or 'between'"),
+        typer.Argument(
+            help="Date operation: 'after', 'before', or 'between'",
+            autocompletion=lambda incomplete: complete_name(
+                incomplete, ["after", "before", "between"]
+            ),
+        ),
     ],
     date_value: Annotated[
         str,
         typer.Argument(
-            help="Date in ISO format (YYYY-MM-DD) or two dates separated by space for 'between'"
+            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
+            ),
         ),
     ],
     end_date: Annotated[
         str | None,
-        typer.Argument(help="End date for 'between' operation (YYYY-MM-DD)"),
+        typer.Argument(
+            help="End date for 'between' operation (YYYY-MM-DD)",
+            autocompletion=lambda incomplete: complete_date(
+                incomplete, Database.START_KEY
+            ),
+        ),
     ] = None,
 ):
     """Limit to sessions in the specified date range.
@@ -116,7 +202,14 @@ def date(
 
 
 @app.command(name="list")
-def list_sessions():
+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:
@@ -127,14 +220,14 @@ def list_sessions():
             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("#", 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="cyan", no_wrap=True
+                "About", style=TABLE_COLUMN_STYLE, no_wrap=True
             )  # type of frames, filter, target
 
             total_images = 0
@@ -143,26 +236,25 @@ def list_sessions():
             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 = 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
+                date_iso = get_key(Database.START_KEY)
+                date = to_shortdate(date_iso)
 
-                object = str(sess.get(Database.OBJECT_KEY, "N/A"))
-                filter = sess.get(Database.FILTER_KEY, "N/A")
+                object = get_key(Database.OBJECT_KEY)
+                filter = get_key(Database.FILTER_KEY)
                 filters.add(filter)
-                image_type = str(sess.get(Database.IMAGETYP_KEY, "N/A"))
+                image_type = get_key(Database.IMAGETYP_KEY)
                 image_types.add(image_type)
-                telescope = str(sess.get(Database.TELESCOP_KEY, "N/A"))
+                telescope = get_key(Database.TELESCOP_KEY)
                 telescopes.add(telescope)
 
                 # Format total exposure time as integer seconds
-                exptime_raw = str(sess.get(Database.EXPTIME_TOTAL_KEY, "N/A"))
+                exptime_raw = get_key(Database.EXPTIME_TOTAL_KEY)
                 try:
                     exptime_float = float(exptime_raw)
                     total_seconds += exptime_float
@@ -172,10 +264,10 @@ def list_sessions():
 
                 # Count images
                 try:
-                    num_images = int(sess.get(Database.NUM_IMAGES_KEY, 0))
+                    num_images = int(get_key(Database.NUM_IMAGES_KEY, 0))
                     total_images += num_images
                 except (ValueError, TypeError):
-                    num_images = sess.get(Database.NUM_IMAGES_KEY, "N/A")
+                    num_images = get_key(Database.NUM_IMAGES_KEY)
 
                 type_str = image_type
                 if image_type.upper() == "LIGHT":
@@ -218,6 +310,32 @@ def list_sessions():
             sb.analytics.set_data("session.image_types", image_types)
 
 
+def selection_by_number(
+    sb: Starbash,
+    session_num: int,
+) -> SessionRow:
+    """Get the session corresponding to the given session number in the current selection."""
+    # 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]
+    return session
+
+
 @app.command()
 def export(
     session_num: Annotated[
@@ -237,36 +355,16 @@ def export(
     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]
+        session = selection_by_number(sb, session_num)
 
-        # Get the session's database row ID
-        session_id = session.get("id")
-        if session_id is None:
+        # Get images for this session
+        images = sb.get_session_images(session)
+        if not images:
             console.print(
-                f"[red]Error: Could not find session ID for session {session_num}.[/red]"
+                f"[red]Error: No images found for session {session_num}.[/red]"
             )
-            raise typer.Exit(1)
+            raise typer.Exit(0)
 
         # Determine output directory
         output_dir = Path(destdir)
@@ -274,15 +372,6 @@ def export(
         # 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)
 
 
@@ -300,8 +389,8 @@ def show_selection(ctx: typer.Context):
                 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")
+                table.add_column("Criteria", style=TABLE_COLUMN_STYLE)
+                table.add_column("Value", style=TABLE_VALUE_STYLE)
 
                 for criterion in summary["criteria"]:
                     parts = criterion.split(": ", 1)