starbash 0.1.0__py3-none-any.whl

starbash/__init__.py

@@ -0,0 +1,6 @@
+from .database import Database  # re-export for convenience
+from rich.console import Console
+
+console = Console()
+
+__all__ = ["Database"]

starbash/app.py

@@ -0,0 +1,228 @@
+import logging
+from importlib import resources
+
+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.tool import Tool
+from starbash.repo import RepoManager
+from starbash.tool import tools
+
+
+def setup_logging():
+    """
+    Configures basic logging.
+    """
+    logging.basicConfig(
+        level="INFO",  # don't print messages of lower priority than this
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(rich_tracebacks=True)],
+    )
+
+
+setup_logging()
+
+
+class AstroGlue:
+    """The main AstroGlue application class."""
+
+    def __init__(self):
+        """
+        Initializes the AstroGlue application by loading configurations
+        and setting up the repository manager.
+        """
+        setup_logging()
+        logging.info("AstroGlue application initializing...")
+
+        # 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)
+        logging.info(
+            f"Repo manager initialized with {len(self.repo_manager.repos)} default repo references."
+        )
+        # self.repo_manager.dump()
+
+        self.db = Database()
+        # FIXME, call reindex somewhere and also index whenever new repos are added
+        # self.reindex_repos()
+
+    # --- Lifecycle ---
+    def close(self) -> None:
+        self.db.close()
+
+    # Context manager support
+    def __enter__(self) -> "AstroGlue":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    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"]
+
+        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:
+                        # 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()
+                            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)
+
+        logging.info("Reindexing complete.")
+
+    def test_processing(self):
+        """A crude test of image processing pipeline - FIXME move into testing"""
+        self.run_all_stages()
+
+    def run_all_stages(self):
+        """On the currently active session, run all processing stages"""
+        logging.info("--- Running all stages ---")
+
+        # 1. Get all pipeline definitions (the `[[stages]]` tables with name and priority).
+        pipeline_definitions = self.repo_manager.merged.getall("stages")
+        flat_pipeline_steps = list(itertools.chain.from_iterable(pipeline_definitions))
+
+        # 2. Sort the pipeline steps by their 'priority' field.
+        try:
+            sorted_pipeline = sorted(flat_pipeline_steps, key=lambda s: s["priority"])
+        except KeyError as e:
+            # Re-raise as a ValueError with a more descriptive message.
+            raise ValueError(
+                f"invalid stage definition: a stage is missing the required 'priority' key"
+            ) from e
+
+        # 3. Get all available task definitions (the `[[stage]]` tables with tool, script, when).
+        task_definitions = self.repo_manager.merged.getall("stage")
+        all_tasks = list(itertools.chain.from_iterable(task_definitions))
+
+        logging.info(
+            f"Found {len(sorted_pipeline)} pipeline steps to run in order of priority."
+        )
+
+        self.start_session()
+        # 4. Iterate through the sorted pipeline and execute the associated tasks.
+        for step in sorted_pipeline:
+            step_name = step.get("name")
+            if not step_name:
+                raise ValueError("Invalid pipeline step found: missing 'name' key.")
+
+            logging.info(
+                f"--- Running pipeline step: '{step_name}' (Priority: {step['priority']}) ---"
+            )
+            # Find all tasks that should run during this pipeline step.
+            tasks_to_run = [task for task in all_tasks if task.get("when") == step_name]
+            for task in tasks_to_run:
+                self.run_stage(task)
+
+    def start_session(self) -> None:
+        """Do common session init"""
+
+        # Context is preserved through all stages, so each stage can add new symbols to it for use by later stages
+        self.context = {}
+
+        # Update the context with runtime values.
+        runtime_context = {
+            "process_dir": "/workspaces/starbash/images/process",  # FIXME - create/find this more correctly per session
+            "masters": "/workspaces/starbash/images/masters",  # FIXME find this the correct way
+        }
+        self.context.update(runtime_context)
+
+    def run_stage(self, stage: dict) -> None:
+        """
+        Executes a single processing stage.
+
+        Args:
+            stage: A dictionary representing the stage configuration, containing
+                   at least 'tool' and 'script' keys.
+        """
+        stage_desc = stage.get("description", "(missing description)")
+        stage_disabled = stage.get("disabled", False)
+        if stage_disabled:
+            logging.info(f"Skipping disabled stage: {stage_desc}")
+            return
+
+        logging.info(f"Running stage: {stage_desc}")
+
+        tool_name = stage.get("tool")
+        if not tool_name:
+            raise ValueError(
+                f"Stage '{stage.get('name')}' is missing a 'tool' definition."
+            )
+        tool: Tool | None = tools.get(tool_name)
+        if not tool:
+            raise ValueError(
+                f"Tool '{tool_name}' for stage '{stage.get('name')}' not found."
+            )
+        logging.debug(f"  Using tool: {tool_name}")
+
+        script_filename = stage.get("script-file", tool.default_script_file)
+        if script_filename:
+            source = stage.source  # type: ignore (was monkeypatched by repo)
+            script = source.read(script_filename)
+        else:
+            script = stage.get("script")
+
+        if script is None:
+            raise ValueError(
+                f"Stage '{stage.get('name')}' is missing a 'script' or 'script-file' definition."
+            )
+
+        # This allows recipe TOML to define their own default variables.
+        stage_context = stage.get("context", {})
+        self.context.update(stage_context)
+
+        # Assume no files for this stage
+        if "input_files" in self.context:
+            del self.context["input_files"]
+
+        input_files = []
+        input_config = stage.get("input")
+        input_required = False
+        if input_config:
+            # if there is an "input" dict, we assume input.required is true if unset
+            input_required = input_config.get("required", True)
+            if "path" in input_config:
+                # The path might contain context variables that need to be expanded.
+                # path_pattern = expand_context(input_config["path"], context)
+                path_pattern = input_config["path"]
+                input_files = glob.glob(path_pattern, recursive=True)
+
+            self.context["input_files"] = (
+                input_files  # Pass in the file list via the context dict
+            )
+
+        if input_required and not input_files:
+            raise RuntimeError("No input files found for stage")
+
+        tool.run_in_temp_dir(script, context=self.context)

starbash/appdefaults.sb.toml

@@ -0,0 +1,89 @@
+
+
+[repo]
+kind = "preferences"
+
+# FIXME, somewhere here list default patterns which can be used to identify NINA, ASIAIR, SEESTAR
+# raw repo layouts
+
+# List the initial search path to find other repos, when the app launches it always first loads this sb.toml file and this file should list all of the
+# standard default repo locations.  When searching repos, repos listed LAST have precedence, so target file can override the root processing defaults,
+# then the user prefs, then a live github URL or whatever
+
+# [[repo.ref]]
+# Possibly provide default repos via http from github?
+# url = "https://github.com/geeksville/starbash-default-repo"
+
+[[repo.ref]]
+
+# Add our built-in recipes (FIXME, add a "resource" repo type for directories we expect to find inside
+# our python blob)
+dir = "/workspaces/starbash/doc/toml/example/recipe-repo"
+
+[[repo.ref]]
+
+# User custom settings live here
+# For "dir" or "url" repos we expect to find an starbash.toml file in the root of the directory.
+# dir = "~/.config/starbash"
+# But temporarily during early development I'm keeping them in the master github
+dir = "/workspaces/starbash/doc/toml/example/config/user/"
+
+# [[repo.ref]]
+
+# recipe repos contain recipes (identified by name).  When any sb.toml file references
+# a recipe the current path of all sources is searched to find that named recipe.
+
+# the standard config includes a few key recipe repos, but interested users or tool
+# vendors can define/provide their own
+
+# add a place to find FOO.sb.toml files
+# url = "http://fixme.com/foo-repo/somedir"
+
+# test data.  Moved to user preferences (where it should should have been all along)
+# [[repo.ref]]
+# dir = "~/Pictures/telescope/from_astroboy"
+
+
+# or inband?
+
+
+# allow including multiple recipies FIXME old idea, not sure if needed.
+# [[repo.ref]]
+
+# looks for a file with this name and .py for the code and .toml for the config
+# we'll expect that toml file to contain various [[recipe.*]] sections which will be loaded at this
+# location in the sequence as if they were defined here
+#by-file = "process-osc-dual-duo"
+#by-url = "http:..."
+
+[config]
+
+# What fits fields should we store in our DB cache
+fits-whitelist = [
+    "INSTRUME",
+    "FILTER",
+    "TELESCOP",
+    "IMAGETYP",
+    "DATE-OBS",
+    "DATE-LOC",
+    "DATE",
+    "EXPTIME",
+    "FWHEEL",
+    "OBJECT",
+    "RA",       # we ignore the text version OBJCTRA / OBJCTDEC
+    "DEC",
+    "OBJCTROT",
+    "FOCPOS",
+    "SITELAT",
+    "SITELON",
+    "SITEELEV",
+    "NAXIS1",
+    "NAXIS2",
+    "SWCREATE",
+    "XBINNING",
+    "YBINNING",
+    "GAIN",
+    "CCD-TEMP",
+    "SET-TEMP",
+    "AMBTEMP",
+]

starbash/commands/repo.py

@@ -0,0 +1,51 @@
+import typer
+from typing_extensions import Annotated
+
+from starbash.app import AstroGlue
+from starbash import console
+
+app = typer.Typer()
+
+
+@app.command()
+def add(path: str):
+    """
+    Add a repository. path is either a local path or a remote URL.
+    """
+    pass
+
+
+@app.command()
+def remove(reponame: str):
+    """
+    Remove a repository by name or number.
+    """
+    pass
+
+
+@app.command()
+def list():
+    """
+    List all repositories.  The listed names/numbers can be used with other commands.
+    """
+    with AstroGlue() as ag:
+        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."),
+    ],
+):
+    """
+    Reindex the named repository.
+    If no name is given, reindex all repositories.
+    """
+    pass
+
+
+if __name__ == "__main__":
+    app()

starbash/database.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from tinydb import TinyDB, Query, table
+from platformdirs import PlatformDirs
+
+
+class Database:
+    """TinyDB-backed application database.
+
+    Stores data under the OS-specific user data directory using platformdirs.
+    Provides an `images` table for FITS metadata and basic helpers.
+    """
+
+    def __init__(
+        self,
+        base_dir: Optional[Path] = None,
+    ) -> None:
+        # Resolve base data directory (allow override for tests)
+        if base_dir is None:
+            app_name = "starbash"
+            app_author = "geeksville"
+            dirs = PlatformDirs(app_name, app_author)
+            data_dir = Path(dirs.user_data_dir)
+        else:
+            data_dir = base_dir
+
+        db_filename = "db.json"
+        data_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = data_dir / db_filename
+
+        # Open TinyDB JSON store
+        self._db = TinyDB(self.db_path)
+
+        # Public handle to the images table
+        self.images = self._db.table("images")
+
+    def add_from_fits(self, file_path: Path, headers: dict[str, Any]) -> None:
+        data = {}
+        data.update(headers)
+        data["path"] = str(file_path)
+        self.upsert_image(data)
+
+    # --- Convenience helpers for common image operations ---
+    def upsert_image(self, record: dict[str, Any]) -> None:
+        """Insert or update an image record by unique path.
+
+        The record must include a 'path' key; other keys are arbitrary FITS metadata.
+        """
+        path = record.get("path")
+        if not path:
+            raise ValueError("record must include 'path'")
+
+        Image = Query()
+        self.images.upsert(record, Image.path == path)
+
+    def get_image(self, path: str) -> table.Document | list[table.Document] | None:
+        Image = Query()
+        return self.images.get(Image.path == path)
+
+    def all_images(self) -> list[dict[str, Any]]:
+        return list(self.images.all())
+
+    # --- Lifecycle ---
+    def close(self) -> None:
+        self._db.close()
+
+    # Context manager support
+    def __enter__(self) -> "Database":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()

starbash/main.py

@@ -0,0 +1,27 @@
+import logging
+import typer
+
+from .app import AstroGlue
+from .commands import repo
+
+app = typer.Typer()
+app.add_typer(repo.app, name="repo", help="Manage Starbash repositories.")
+
+
+@app.command(hidden=True)
+def default_cmd():
+    """Default entry point for the starbash application."""
+
+    with AstroGlue() as ag:
+        pass
+
+
+@app.callback(invoke_without_command=True)
+def _default(ctx: typer.Context):
+    # If the user didn’t specify a subcommand, run the default
+    if ctx.invoked_subcommand is None:
+        return default_cmd()
+
+
+if __name__ == "__main__":
+    app()

starbash/repo/__init__.py

@@ -0,0 +1,7 @@
+"""
+The repo package handles finding, loading and searching starbash repositories.
+"""
+
+from .manager import RepoManager
+
+__all__ = ["RepoManager"]