starbash 0.1.1__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

@@ -1,7 +1,7 @@
 import logging
 from importlib import resources
 from pathlib import Path
-
+import typer
 import tomlkit
 from tomlkit.toml_file import TOMLFile
 import glob
@@ -10,6 +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
@@ -31,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:
@@ -89,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()
 
@@ -117,7 +172,8 @@ class Starbash:
 
     def __exit__(self, exc_type, exc, tb) -> bool:
         handled = False
-        if exc:
+        # Don't suppress typer.Exit - it's used for controlled exit codes
+        if exc and not isinstance(exc, typer.Exit):
             handled = analytics_exception(exc)
         self.close()
         return handled
@@ -128,11 +184,12 @@ class Starbash:
         date = header.get(Database.DATE_OBS_KEY)
         if not date or not image_type:
             logging.warning(
-                "Image %s missing critical FITS header, please submit image at https://github.com/geeksville/starbash/issues/new",
+                "Image %s missing either DATE-OBS or IMAGETYP FITS header, skipping...",
                 f,
             )
         else:
             exptime = header.get(Database.EXPTIME_KEY, 0)
+            telescop = header.get(Database.TELESCOP_KEY, "unspecified")
             new = {
                 Database.FILTER_KEY: filter,
                 Database.START_KEY: date,
@@ -142,6 +199,7 @@ class Starbash:
                 Database.NUM_IMAGES_KEY: 1,
                 Database.EXPTIME_TOTAL_KEY: exptime,
                 Database.OBJECT_KEY: header.get(Database.OBJECT_KEY, "unspecified"),
+                Database.TELESCOP_KEY: telescop,
             }
             session = self.db.get_session(new)
             self.db.upsert_session(new, existing=session)
@@ -156,16 +214,86 @@ class Starbash:
             conditions = self.selection.get_query_conditions()
             return self.db.search_session(conditions)
 
+    def get_session_images(self, session_id: int) -> list[dict[str, Any]]:
+        """
+        Get all images belonging to a specific session.
+
+        Sessions are defined by a unique combination of filter, imagetyp (image type),
+        object (target name), telescope, and date range. This method queries the images
+        table for all images matching the session's criteria in a single database query.
+
+        Args:
+            session_id: The database ID of the session
+
+        Returns:
+            List of image records (dictionaries with path, metadata, etc.)
+            Returns empty list if session not found or has no images.
+
+        Raises:
+            ValueError: If session_id is not found in the database
+        """
+        # First get the session details
+        session = self.db.get_session_by_id(session_id)
+        if session is None:
+            raise ValueError(f"Session with id {session_id} not found")
+
+        # Query images that match ALL session criteria including date range
+        conditions = {
+            Database.FILTER_KEY: session[Database.FILTER_KEY],
+            Database.IMAGETYP_KEY: session[Database.IMAGETYP_KEY],
+            Database.OBJECT_KEY: session[Database.OBJECT_KEY],
+            Database.TELESCOP_KEY: session[Database.TELESCOP_KEY],
+            "date_start": session[Database.START_KEY],
+            "date_end": session[Database.END_KEY],
+        }
+
+        # Single query with all conditions
+        images = self.db.search_image(conditions)
+        return images if images else []
+
+    def remove_repo_ref(self, url: str) -> None:
+        """
+        Remove a repository reference from the user configuration.
+
+        Args:
+            url: The repository URL to remove (e.g., 'file:///path/to/repo')
+
+        Raises:
+            ValueError: If the repository URL is not found in user configuration
+        """
+        # Get the repo-ref list from user config
+        repo_refs = self.user_repo.config.get("repo-ref")
+
+        if not repo_refs:
+            raise ValueError(f"No repository references found in user configuration.")
+
+        # Find and remove the matching repo-ref
+        found = False
+        refs_copy = [r for r in repo_refs]  # Make a copy to iterate
+        for ref in refs_copy:
+            ref_dir = ref.get("dir", "")
+            # Match by converting to file:// URL format if needed
+            if ref_dir == url or f"file://{ref_dir}" == url:
+                repo_refs.remove(ref)
+                found = True
+                break
+
+        if not found:
+            raise ValueError(f"Repository '{url}' not found in user configuration.")
+
+        # Write the updated config
+        self.user_repo.write_config()
+
     def reindex_repo(self, repo: Repo, force: bool = False):
         """Reindex all repositories managed by the RepoManager."""
         # FIXME, add a method to get just the repos that contain images
         if repo.is_scheme("file") and repo.kind != "recipe":
             logging.debug("Reindexing %s...", repo.url)
 
+            whitelist = None
             config = self.repo_manager.merged.get("config")
-            if not config:
-                raise ValueError(f"App config not found.")
-            whitelist = config["fits-whitelist"]
+            if config:
+                whitelist = config.get("fits-whitelist", None)
 
             path = repo.get_path()
             if not path:
@@ -191,7 +319,7 @@ class Starbash:
                             items = header.items()
                             headers = {}
                             for key, value in items:
-                                if key in whitelist:
+                                if (not whitelist) or (key in whitelist):
                                     headers[key] = value
                             logging.debug("Headers for %s: %s", f, headers)
                             headers["path"] = str(f)
@@ -207,7 +335,7 @@ class Starbash:
 
     def reindex_repos(self, force: bool = False):
         """Reindex all repositories managed by the RepoManager."""
-        logging.info("Reindexing all repositories...")
+        logging.debug("Reindexing all repositories...")
 
         for repo in track(self.repo_manager.repos, description="Reindexing repos..."):
             self.reindex_repo(repo, force=force)

starbash/commands/repo.py

@@ -4,64 +4,136 @@ from typing_extensions import Annotated
 from starbash.app import Starbash
 from starbash import console
 
-app = typer.Typer()
+app = typer.Typer(invoke_without_command=True)
 
 
-@app.command()
-def add(path: str):
+@app.callback()
+def main(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show all repos including system repos"
+    ),
+):
     """
-    Add a repository. path is either a local path or a remote URL.
+    Manage repositories.
+
+    When called without a subcommand, lists all repositories.
+    Use --verbose to show all repos including system/recipe repos.
     """
-    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}")
+    # If no subcommand is invoked, run the list behavior
+    if ctx.invoked_subcommand is None:
+        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={ kind })")
+                else:
+                    # Show numbers for user repos (can be removed later)
+                    console.print(f"{ i + 1:2}: { repo.url } (kind={ kind })")
 
 
 @app.command()
-def remove(reponame: str):
+def add(path: str):
     """
-    Remove a repository by name or number.
+    Add a repository. path is either a local path or a remote URL.
     """
-    with Starbash("repo-remove") as sb:
-        raise NotImplementedError("Removing repositories not yet implemented.")
+    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()
-def list():
+def remove(reponum: str):
     """
-    List all repositories.  The listed names/numbers can be used with other commands.
+    Remove a repository by number (from list).
+    Use 'starbash repo' to see the repository numbers.
     """
-    with Starbash("repo-list") as sb:
-        for i, repo in enumerate(sb.repo_manager.repos):
-            console.print(f"{ i + 1:2}: { repo.url } (kind={ repo.kind})")
+    with Starbash("repo.remove") as sb:
+        try:
+            # Parse the repo number (1-indexed)
+            repo_index = int(reponum) - 1
+
+            # Get only the regular (user-visible) repos
+            regular_repos = sb.repo_manager.regular_repos
+
+            if repo_index < 0 or repo_index >= len(regular_repos):
+                console.print(
+                    f"[red]Error: Repository number {reponum} is out of range. Valid range: 1-{len(regular_repos)}[/red]"
+                )
+                raise typer.Exit(code=1)
+
+            # Get the repo to remove
+            repo_to_remove = regular_repos[repo_index]
+            repo_url = repo_to_remove.url
+
+            # Remove the repo reference from user config
+            sb.remove_repo_ref(repo_url)
+            console.print(f"[green]Removed repository: {repo_url}[/green]")
+
+        except ValueError:
+            console.print(
+                f"[red]Error: '{reponum}' is not a valid repository number. Please use a number from 'repo list'.[/red]"
+            )
+            raise typer.Exit(code=1)
 
 
 @app.command()
 def reindex(
-    repo: Annotated[
+    reponum: Annotated[
         str | None,
-        typer.Argument(
-            help="The repository name or number, if not specified reindex all."
-        ),
+        typer.Argument(help="The repository number, if not specified reindex all."),
     ] = None,
     force: bool = typer.Option(
         default=False, help="Reread FITS headers, even if they are already indexed."
     ),
 ):
     """
-    Reindex the named repository.
-    If no name is given, reindex all repositories.
+    Reindex a repository by number.
+    If no number is given, reindex all repositories.
+    Use 'starbash repo' to see the repository numbers.
     """
-    with Starbash("repo-reindex") as sb:
-        if repo is None:
-            console.print("Reindexing all repositories...")
+    with Starbash("repo.reindex") as sb:
+        if reponum is None:
             sb.reindex_repos(force=force)
         else:
-            raise NotImplementedError("Reindexing a single repo not yet implemented.")
+            try:
+                # Parse the repo number (1-indexed)
+                repo_index = int(reponum) - 1
+
+                # Get only the regular (user-visible) repos
+                regular_repos = sb.repo_manager.regular_repos
+
+                if repo_index < 0 or repo_index >= len(regular_repos):
+                    console.print(
+                        f"[red]Error: Repository number {reponum} is out of range. Valid range: 1-{len(regular_repos)}[/red]"
+                    )
+                    raise typer.Exit(code=1)
+
+                # Get the repo to reindex
+                repo_to_reindex = regular_repos[repo_index]
+                console.print(f"Reindexing repository: {repo_to_reindex.url}")
+                sb.reindex_repo(repo_to_reindex, force=force)
+                console.print(
+                    f"[green]Successfully reindexed repository {reponum}[/green]"
+                )
+
+            except ValueError:
+                console.print(
+                    f"[red]Error: '{reponum}' is not a valid repository number. Please use a number from 'starbash repo'.[/red]"
+                )
+                raise typer.Exit(code=1)
 
 
 if __name__ == "__main__":