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

starbash/analytics.py

@@ -0,0 +1,121 @@
+import logging
+
+from starbash import console
+import starbash.url as url
+
+# Default to no analytics/auto crash reports
+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:
+        logging.info(
+            f"Analytics/crash-reports enabled.  To change [link={url.analytics_docs}]click here[/link]",
+            extra={"markup": True},
+        )
+        sentry_sdk.init(
+            dsn="https://e9496a4ea8b37a053203a2cbc10d64e6@o209837.ingest.us.sentry.io/4510264204132352",
+            send_default_pii=True,
+            enable_logs=True,
+            traces_sample_rate=1.0,
+        )
+
+        if user_email:
+            sentry_sdk.set_user({"email": user_email})
+    else:
+        logging.info(
+            f"Analytics/crash-reports disabled.  To learn more [link={url.analytics_docs}]click here[/link]",
+            extra={"markup": True},
+        )
+
+
+def analytics_shutdown() -> None:
+    """Shut down the analytics service, if enabled."""
+    if analytics_allowed:
+        import sentry_sdk
+
+        sentry_sdk.flush()
+
+
+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":
+        return True
+
+    # Check if running under VS Code
+    if any(k.startswith("VSCODE_") for k in os.environ):
+        return True
+
+    return False
+
+
+def analytics_exception(exc: Exception) -> bool:
+    """Report an exception to the analytics service, if enabled.
+    return True to suppress exception propagation/log messages"""
+
+    if is_development_environment():
+        return False  # We want to let devs see full exception traces
+
+    if analytics_allowed:
+        import sentry_sdk
+
+        report_id = sentry_sdk.capture_exception(exc)
+
+        logging.info(
+            f"""An unexpected error has occurred and been reported.  Thank you for your help.
+                If you'd like to chat with the devs about it, please click
+                [link={url.new_issue(str(report_id))}]here[/link] to open an issue.""",
+            extra={"markup": True},
+        )
+    else:
+        logging.error(
+            f"""An unexpected error has occurred. Automated crash reporting is disabled,
+                      but we encourage you to contact the developers
+                      at [link={url.new_issue()}]here[/link] and we will try to help.
+
+                      The full exception is: {exc}""",
+            extra={"markup": True},
+        )
+    return True
+
+
+class NopAnalytics:
+    """Used when users have disabled analytics/crash reporting."""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        return False
+
+    def set_data(self, key, value):
+        pass
+
+
+def analytics_start_span(**kwargs):
+    """Start an analytics/tracing span if analytics is enabled, otherwise return a no-op context manager."""
+    if analytics_allowed:
+        import sentry_sdk
+
+        return sentry_sdk.start_span(**kwargs)
+    else:
+        return NopAnalytics()
+
+
+def analytics_start_transaction(**kwargs):
+    """Start an analytics/tracing transaction if analytics is enabled, otherwise return a no-op context manager."""
+    if analytics_allowed:
+        import sentry_sdk
+
+        return sentry_sdk.start_transaction(**kwargs)
+    else:
+        return NopAnalytics()

starbash/app.py

@@ -1,16 +1,30 @@
 import logging
 from importlib import resources
-
+from pathlib import Path
+import typer
+import tomlkit
+from tomlkit.toml_file import TOMLFile
 import glob
 from typing import Any
 from astropy.io import fits
 import itertools
 from rich.progress import track
 from rich.logging import RichHandler
+
 from starbash.database import Database
+from starbash.repo.manager import Repo
 from starbash.tool import Tool
 from starbash.repo import RepoManager
 from starbash.tool import tools
+from starbash.paths import get_user_config_dir, get_user_data_dir
+from starbash.selection import Selection
+from starbash.analytics import (
+    NopAnalytics,
+    analytics_exception,
+    analytics_setup,
+    analytics_shutdown,
+    analytics_start_transaction,
+)
 
 
 def setup_logging():
@@ -28,78 +42,249 @@ def setup_logging():
 setup_logging()
 
 
-class AstroGlue:
-    """The main AstroGlue application class."""
+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():
+        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
+
+
+class Starbash:
+    """The main Starbash application class."""
 
-    def __init__(self):
+    def __init__(self, cmd: str = "unspecified"):
         """
-        Initializes the AstroGlue application by loading configurations
+        Initializes the Starbash application by loading configurations
         and setting up the repository manager.
         """
         setup_logging()
-        logging.info("AstroGlue application initializing...")
+        logging.info("Starbash starting...")
 
         # Load app defaults and initialize the repository manager
-        app_defaults_text = (
-            resources.files("starbash").joinpath("appdefaults.sb.toml").read_text()
-        )
-        self.repo_manager = RepoManager(app_defaults_text)
+        self.repo_manager = RepoManager()
+        self.repo_manager.add_repo("pkg://defaults")
+
+        # Add user prefs as a repo
+        self.user_repo = self.repo_manager.add_repo("file://" + str(create_user()))
+
+        self.analytics = NopAnalytics()
+        if self.user_repo.get("analytics.enabled", True):
+            include_user = self.user_repo.get("analytics.include_user", False)
+            user_email = (
+                self.user_repo.get("user.email", None) if include_user else None
+            )
+            if user_email is not None:
+                user_email = str(user_email)
+            analytics_setup(allowed=True, user_email=user_email)
+            # this is intended for use with "with" so we manually do enter/exit
+            self.analytics = analytics_start_transaction(name="App session", op=cmd)
+            self.analytics.__enter__()
+
         logging.info(
             f"Repo manager initialized with {len(self.repo_manager.repos)} default repo references."
         )
         # self.repo_manager.dump()
 
         self.db = Database()
+        self.session_query = None  # None means search all sessions
+
+        # Initialize selection state
+        data_dir = get_user_data_dir()
+        selection_file = data_dir / "selection.json"
+        self.selection = Selection(selection_file)
+
         # FIXME, call reindex somewhere and also index whenever new repos are added
         # self.reindex_repos()
 
     # --- Lifecycle ---
     def close(self) -> None:
+        self.analytics.__exit__(None, None, None)
+
+        analytics_shutdown()
         self.db.close()
 
     # Context manager support
-    def __enter__(self) -> "AstroGlue":
+    def __enter__(self) -> "Starbash":
         return self
 
-    def __exit__(self, exc_type, exc, tb) -> None:
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        handled = False
+        # 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
+
+    def _add_session(self, f: str, image_doc_id: int, header: dict) -> None:
+        filter = header.get(Database.FILTER_KEY, "unspecified")
+        image_type = header.get(Database.IMAGETYP_KEY)
+        date = header.get(Database.DATE_OBS_KEY)
+        if not date or not image_type:
+            logging.warning(
+                "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,
+                Database.END_KEY: date,  # FIXME not quite correct, should be longer by exptime
+                Database.IMAGE_DOC_KEY: image_doc_id,
+                Database.IMAGETYP_KEY: image_type,
+                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)
+
+    def search_session(self) -> list[dict[str, Any]] | None:
+        """Search for sessions, optionally filtered by the current selection."""
+        # If selection has filters, use them; otherwise return all sessions
+        if self.selection.is_empty():
+            return self.db.search_session(None)
+        else:
+            # Get query conditions from selection
+            conditions = self.selection.get_query_conditions()
+            return self.db.search_session(conditions)
 
-    def reindex_repos(self):
-        """Reindex all repositories managed by the RepoManager."""
-        logging.info("Reindexing all repositories...")
-        config = self.repo_manager.merged.get("config")
-        if not config:
-            raise ValueError(f"App config not found.")
-        whitelist = config["fits-whitelist"]
+    def get_session_images(self, session_id: int) -> list[dict[str, Any]]:
+        """
+        Get all images belonging to a specific session.
 
-        for repo in track(self.repo_manager.repos, description="Reindexing repos..."):
-            # FIXME, add a method to get just the repos that contain images
-            if repo.is_local and repo.kind != "recipe":
-                logging.debug("Reindexing %s...", repo.url)
-                path = repo.get_path()
-
-                # Find all FITS files under this repo path
-                for f in track(
-                    list(path.rglob("*.fit*")),
-                    description=f"Indexing {repo.url}...",
-                ):
-                    # progress.console.print(f"Indexing {f}...")
-                    try:
+        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 config:
+                whitelist = config.get("fits-whitelist", None)
+
+            path = repo.get_path()
+            if not path:
+                raise ValueError(f"Repo path not found for {repo}")
+
+            # Find all FITS files under this repo path
+            for f in track(
+                list(path.rglob("*.fit*")),
+                description=f"Indexing {repo.url}...",
+            ):
+                # progress.console.print(f"Indexing {f}...")
+                try:
+                    found = self.db.get_image(str(f))
+                    if not found or force:
                         # Read and log the primary header (HDU 0)
                         with fits.open(str(f), memmap=False) as hdul:
                             # convert headers to dict
                             hdu0: Any = hdul[0]
-                            items = hdu0.header.items()
+                            header = hdu0.header
+                            if type(header).__name__ == "Unknown":
+                                raise ValueError("FITS header has Unknown type: %s", f)
+
+                            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)
-                            self.db.add_from_fits(f, headers)
-                    except Exception as e:
-                        logging.warning("Failed to read FITS header for %s: %s", f, e)
+                            headers["path"] = str(f)
+                            image_doc_id = self.db.upsert_image(headers)
+
+                            if not found:
+                                # Update the session infos, but ONLY on first file scan
+                                # (otherwise invariants will get messed up)
+                                self._add_session(str(f), image_doc_id, header)
 
-        logging.info("Reindexing complete.")
+                except Exception as e:
+                    logging.warning("Failed to read FITS header for %s: %s", f, e)
+
+    def reindex_repos(self, force: bool = False):
+        """Reindex all repositories managed by the RepoManager."""
+        logging.debug("Reindexing all repositories...")
+
+        for repo in track(self.repo_manager.repos, description="Reindexing repos..."):
+            self.reindex_repo(repo, force=force)
 
     def test_processing(self):
         """A crude test of image processing pipeline - FIXME move into testing"""

starbash/commands/repo.py

@@ -1,50 +1,132 @@
 import typer
 from typing_extensions import Annotated
 
-from starbash.app import AstroGlue
+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.
     """
-    pass
+    # 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):
+                if verbose:
+                    # No numbers for verbose mode (system repos can't be removed)
+                    console.print(f"{ repo.url } (kind={ repo.kind})")
+                else:
+                    # Show numbers for user repos (can be removed later)
+                    console.print(f"{ i + 1:2}: { repo.url } (kind={ repo.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.
     """
-    pass
+    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}")
 
 
 @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 AstroGlue() as ag:
-        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(
-    reponame: Annotated[
-        str,
-        typer.Argument(help="The repository name or number, or none to reindex all."),
-    ],
+    reponum: Annotated[
+        str | None,
+        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.
     """
-    pass
+    with Starbash("repo-reindex") as sb:
+        if reponum is None:
+            sb.reindex_repos(force=force)
+        else:
+            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__":