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

starbash/commands/select.py

@@ -2,18 +2,20 @@
 
 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, get_column_name
+from starbash.database import Database, SessionRow, get_column_name
 from starbash import console
 from starbash.commands import (
     format_duration,
-    to_shortdate,
     TABLE_COLUMN_STYLE,
     TABLE_VALUE_STYLE,
 )
@@ -21,6 +23,58 @@ from starbash.commands import (
 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.lower().startswith(incomplete.lower()):
+                yield (item, f"{count} sessions")
+
+
 @app.command(name="any")
 def clear():
     """Remove any filters on sessions, etc... (select everything)."""
@@ -34,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
+            ),
         ),
     ],
 ):
@@ -52,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
+            ),
         ),
     ],
 ):
@@ -67,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.
@@ -122,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:
@@ -166,6 +253,13 @@ def list_sessions():
                 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:
@@ -223,6 +317,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[
@@ -242,36 +362,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)
@@ -279,15 +379,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)