starbash 0.1.0__py3-none-any.whl → 0.1.1__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,6 +1,9 @@
 import logging
 from importlib import resources
+from pathlib import Path
 
+import tomlkit
+from tomlkit.toml_file import TOMLFile
 import glob
 from typing import Any
 from astropy.io import fits
@@ -8,9 +11,19 @@ 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 +41,176 @@ 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
+        if exc:
+            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 critical FITS header, please submit image at https://github.com/geeksville/starbash/issues/new",
+                f,
+            )
+        else:
+            exptime = header.get(Database.EXPTIME_KEY, 0)
+            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"),
+            }
+            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):
+    def reindex_repo(self, repo: Repo, force: bool = False):
         """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"]
-
-        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:
+        # 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)
+
+            config = self.repo_manager.merged.get("config")
+            if not config:
+                raise ValueError(f"App config not found.")
+            whitelist = config["fits-whitelist"]
+
+            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:
                                     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)
 
-        logging.info("Reindexing complete.")
+                            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)
+
+                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.info("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,7 +1,7 @@
 import typer
 from typing_extensions import Annotated
 
-from starbash.app import AstroGlue
+from starbash.app import Starbash
 from starbash import console
 
 app = typer.Typer()
@@ -12,7 +12,13 @@ def add(path: str):
     """
     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()
@@ -20,7 +26,8 @@ def remove(reponame: str):
     """
     Remove a repository by name or number.
     """
-    pass
+    with Starbash("repo-remove") as sb:
+        raise NotImplementedError("Removing repositories not yet implemented.")
 
 
 @app.command()
@@ -28,23 +35,33 @@ def list():
     """
     List all repositories.  The listed names/numbers can be used with other commands.
     """
-    with AstroGlue() as ag:
+    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})")
 
 
 @app.command()
 def reindex(
-    reponame: Annotated[
-        str,
-        typer.Argument(help="The repository name or number, or none to reindex all."),
-    ],
+    repo: Annotated[
+        str | None,
+        typer.Argument(
+            help="The repository name or 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.
     """
-    pass
+    with Starbash("repo-reindex") as sb:
+        if repo is None:
+            console.print("Reindexing all repositories...")
+            sb.reindex_repos(force=force)
+        else:
+            raise NotImplementedError("Reindexing a single repo not yet implemented.")
 
 
 if __name__ == "__main__":

starbash/commands/selection.py

@@ -0,0 +1,117 @@
+"""Selection commands for filtering sessions and targets."""
+
+import typer
+from typing_extensions import Annotated
+from rich.table import Table
+
+from starbash.app import Starbash
+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.clear()
+        sb.selection.add_target(target_name)
+        console.print(f"[green]Selection limited to target: {target_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)
+
+
+@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)

starbash/commands/user.py

@@ -0,0 +1,63 @@
+import typer
+from typing_extensions import Annotated
+
+from starbash.app import Starbash
+from starbash import console
+
+app = typer.Typer()
+
+
+@app.command()
+def analytics(
+    enable: Annotated[
+        bool,
+        typer.Argument(
+            help="Enable or disable analytics (crash reports and usage data).",
+        ),
+    ],
+):
+    """
+    Enable or disable analytics (crash reports and usage data).
+    """
+    with Starbash("analytics-enable") as sb:
+        sb.analytics.set_data("analytics.enabled", enable)
+        sb.user_repo.config["analytics.enabled"] = enable
+        sb.user_repo.write_config()
+        status = "enabled" if enable else "disabled"
+        console.print(f"Analytics (crash reports) {status}.")
+
+
+@app.command()
+def name(
+    user_name: Annotated[
+        str,
+        typer.Argument(
+            help="Your name for attribution in generated images.",
+        ),
+    ],
+):
+    """
+    Set your name for attribution in generated images.
+    """
+    with Starbash("user-name") as sb:
+        sb.user_repo.config["user.name"] = user_name
+        sb.user_repo.write_config()
+        console.print(f"User name set to: {user_name}")
+
+
+@app.command()
+def email(
+    user_email: Annotated[
+        str,
+        typer.Argument(
+            help="Your email for attribution in generated images.",
+        ),
+    ],
+):
+    """
+    Set your email for attribution in generated images.
+    """
+    with Starbash("user-email") as sb:
+        sb.user_repo.config["user.email"] = user_email
+        sb.user_repo.write_config()
+        console.print(f"User email set to: {user_email}")