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

starbash/__init__.py

@@ -1,6 +1,11 @@
+import logging
+
 from .database import Database  # re-export for convenience
 from rich.console import Console
 
 console = Console()
 
+# Global variable for log filter level (can be changed via --debug flag)
+log_filter_level = logging.INFO
+
 __all__ = ["Database"]

starbash/analytics.py

@@ -1,5 +1,7 @@
 import logging
+import os
 
+import starbash
 from starbash import console
 import starbash.url as url
 
@@ -8,11 +10,12 @@ analytics_allowed = False
 
 
 def analytics_setup(allowed: bool = False, user_email: str | None = None) -> None:
-    import sentry_sdk
-
     global analytics_allowed
     analytics_allowed = allowed
     if analytics_allowed:
+        import sentry_sdk
+        from sentry_sdk.integrations.logging import LoggingIntegration
+
         logging.info(
             f"Analytics/crash-reports enabled.  To change [link={url.analytics_docs}]click here[/link]",
             extra={"markup": True},
@@ -22,6 +25,13 @@ def analytics_setup(allowed: bool = False, user_email: str | None = None) -> Non
             send_default_pii=True,
             enable_logs=True,
             traces_sample_rate=1.0,
+            integrations=[
+                LoggingIntegration(
+                    level=starbash.log_filter_level,  # Capture INFO and above as breadcrumbs
+                    event_level=None,  # Don't automatically convert error messages to sentry events
+                    sentry_logs_level=starbash.log_filter_level,  # Capture INFO and above as logs
+                ),
+            ],
         )
 
         if user_email:
@@ -41,11 +51,13 @@ def analytics_shutdown() -> None:
         sentry_sdk.flush()
 
 
+def is_running_in_pytest() -> bool:
+    """Detect if code is being run inside pytest."""
+    return "PYTEST_CURRENT_TEST" in os.environ
+
+
 def is_development_environment() -> bool:
     """Detect if running in a development environment."""
-    import os
-    import sys
-    from pathlib import Path
 
     # Check for explicit environment variable
     if os.getenv("STARBASH_ENV") == "development":
@@ -68,7 +80,10 @@ def analytics_exception(exc: Exception) -> bool:
     if analytics_allowed:
         import sentry_sdk
 
-        report_id = sentry_sdk.capture_exception(exc)
+        if is_running_in_pytest():
+            report_id = "TESTING-ENVIRONMENT"
+        else:
+            report_id = sentry_sdk.capture_exception(exc)
 
         logging.info(
             f"""An unexpected error has occurred and been reported.  Thank you for your help.

starbash/app.py

@@ -10,7 +10,10 @@ from astropy.io import fits
 import itertools
 from rich.progress import track
 from rich.logging import RichHandler
+import shutil
 
+import starbash
+from starbash import console
 from starbash.database import Database
 from starbash.repo.manager import Repo
 from starbash.tool import Tool
@@ -32,30 +35,81 @@ def setup_logging():
     Configures basic logging.
     """
     logging.basicConfig(
-        level="INFO",  # don't print messages of lower priority than this
+        level=starbash.log_filter_level,  # use the global log filter level
         format="%(message)s",
         datefmt="[%X]",
         handlers=[RichHandler(rich_tracebacks=True)],
     )
 
 
-setup_logging()
+def get_user_config_path() -> Path:
+    """Returns the path to the user config file."""
+    config_dir = get_user_config_dir()
+    return config_dir / "starbash.toml"
 
 
 def create_user() -> Path:
     """Create user directories if they don't exist yet."""
-    config_dir = get_user_config_dir()
-    userconfig_path = config_dir / "starbash.toml"
-    if not (userconfig_path).exists():
+    path = get_user_config_path()
+    if not path.exists():
         tomlstr = (
             resources.files("starbash")
             .joinpath("templates/userconfig.toml")
             .read_text()
         )
         toml = tomlkit.parse(tomlstr)
-        TOMLFile(userconfig_path).write(toml)
-        logging.info(f"Created user config file: {userconfig_path}")
-    return config_dir
+        TOMLFile(path).write(toml)
+        logging.info(f"Created user config file: {path}")
+    return get_user_config_dir()
+
+
+def copy_images_to_dir(images: list[dict[str, Any]], output_dir: Path) -> None:
+    """Copy images to the specified output directory (using symbolic links if possible)."""
+
+    # Export images
+    console.print(f"[cyan]Exporting {len(images)} images to {output_dir}...[/cyan]")
+
+    linked_count = 0
+    copied_count = 0
+    error_count = 0
+
+    for image in images:
+        # Get the source path from the image metadata
+        source_path = Path(image.get("path", ""))
+
+        if not source_path.exists():
+            console.print(f"[red]Warning: Source file not found: {source_path}[/red]")
+            error_count += 1
+            continue
+
+        # Determine destination filename
+        dest_path = output_dir / source_path.name
+        if dest_path.exists():
+            console.print(f"[yellow]Skipping existing file: {dest_path}[/yellow]")
+            error_count += 1
+            continue
+
+        # Try to create a symbolic link first
+        try:
+            dest_path.symlink_to(source_path.resolve())
+            linked_count += 1
+        except (OSError, NotImplementedError):
+            # If symlink fails, try to copy
+            try:
+                shutil.copy2(source_path, dest_path)
+                copied_count += 1
+            except Exception as e:
+                console.print(f"[red]Error copying {source_path.name}: {e}[/red]")
+                error_count += 1
+
+    # Print summary
+    console.print(f"[green]Export complete![/green]")
+    if linked_count > 0:
+        console.print(f"  Linked: {linked_count} files")
+    if copied_count > 0:
+        console.print(f"  Copied: {copied_count} files")
+    if error_count > 0:
+        console.print(f"  [red]Errors: {error_count} files[/red]")
 
 
 class Starbash:
@@ -90,7 +144,7 @@ class Starbash:
             self.analytics.__enter__()
 
         logging.info(
-            f"Repo manager initialized with {len(self.repo_manager.repos)} default repo references."
+            f"Repo manager initialized with {len(self.repo_manager.repos)} repos."
         )
         # self.repo_manager.dump()
 

starbash/commands/repo.py

@@ -22,15 +22,19 @@ def main(
     """
     # If no subcommand is invoked, run the list behavior
     if ctx.invoked_subcommand is None:
-        with Starbash("repo-list") as sb:
+        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={ repo.kind})")
+                    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={ repo.kind})")
+                    console.print(f"{ i + 1:2}: { repo.url } (kind={ kind })")
 
 
 @app.command()
@@ -38,13 +42,16 @@ def add(path: str):
     """
     Add a repository. path is either a local path or a remote URL.
     """
-    with Starbash("repo-add") as sb:
-        sb.user_repo.add_repo_ref(path)
-        # we don't yet 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!!!
-        console.print(f"Added repository: {path}")
+    with Starbash("repo.add") as sb:
+        repo = sb.user_repo.add_repo_ref(path)
+        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
+            # r.write_config()
+            sb.user_repo.write_config()
+            # FIXME, we also need to index the newly added repo!!!
 
 
 @app.command()
@@ -53,7 +60,7 @@ 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:
+    with Starbash("repo.remove") as sb:
         try:
             # Parse the repo number (1-indexed)
             repo_index = int(reponum) - 1
@@ -97,7 +104,7 @@ def reindex(
     If no number is given, reindex all repositories.
     Use 'starbash repo' to see the repository numbers.
     """
-    with Starbash("repo-reindex") as sb:
+    with Starbash("repo.reindex") as sb:
         if reponum is None:
             sb.reindex_repos(force=force)
         else:

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)