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

starbash/database.py

@@ -1,67 +1,397 @@
 from __future__ import annotations
 
+import logging
+import sqlite3
 from pathlib import Path
 from typing import Any, Optional
+from datetime import datetime, timedelta
+import json
 
-from tinydb import TinyDB, Query, table
-from platformdirs import PlatformDirs
+from .paths import get_user_data_dir
 
 
 class Database:
-    """TinyDB-backed application database.
+    """SQLite-backed application database.
 
     Stores data under the OS-specific user data directory using platformdirs.
     Provides an `images` table for FITS metadata and basic helpers.
     """
 
+    EXPTIME_KEY = "EXPTIME"
+    FILTER_KEY = "FILTER"
+    START_KEY = "start"
+    END_KEY = "end"
+    NUM_IMAGES_KEY = "num-images"
+    EXPTIME_TOTAL_KEY = "exptime-total"
+    DATE_OBS_KEY = "DATE-OBS"
+    IMAGE_DOC_KEY = "image-doc"
+    IMAGETYP_KEY = "IMAGETYP"
+    OBJECT_KEY = "OBJECT"
+
     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)
+            data_dir = get_user_data_dir()
         else:
             data_dir = base_dir
 
-        db_filename = "db.json"
-        data_dir.mkdir(parents=True, exist_ok=True)
+        db_filename = "db.sqlite3"
         self.db_path = data_dir / db_filename
 
-        # Open TinyDB JSON store
-        self._db = TinyDB(self.db_path)
+        # Open SQLite database
+        self._db = sqlite3.connect(str(self.db_path))
+        self._db.row_factory = sqlite3.Row  # Enable column access by name
+
+        # Initialize tables
+        self._init_tables()
+
+    def _init_tables(self) -> None:
+        """Create the images and sessions tables if they don't exist."""
+        cursor = self._db.cursor()
+
+        # Create images table
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS images (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                path TEXT UNIQUE NOT NULL,
+                metadata TEXT NOT NULL
+            )
+        """
+        )
+
+        # Create index on path for faster lookups
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_images_path ON images(path)
+        """
+        )
+
+        # Create sessions table
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                start TEXT NOT NULL,
+                end TEXT NOT NULL,
+                filter TEXT NOT NULL,
+                imagetyp TEXT NOT NULL,
+                object TEXT NOT NULL,
+                num_images INTEGER NOT NULL,
+                exptime_total REAL NOT NULL,
+                image_doc_id INTEGER
+            )
+        """
+        )
 
-        # Public handle to the images table
-        self.images = self._db.table("images")
+        # Create index on session attributes for faster queries
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_sessions_lookup
+            ON sessions(filter, imagetyp, object, start, end)
+        """
+        )
 
-    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)
+        self._db.commit()
 
     # --- Convenience helpers for common image operations ---
-    def upsert_image(self, record: dict[str, Any]) -> None:
+    def upsert_image(self, record: dict[str, Any]) -> int:
         """Insert or update an image record by unique path.
 
         The record must include a 'path' key; other keys are arbitrary FITS metadata.
+        Returns the rowid of the inserted/updated record.
         """
         path = record.get("path")
         if not path:
             raise ValueError("record must include 'path'")
 
-        Image = Query()
-        self.images.upsert(record, Image.path == path)
+        # Separate path from metadata
+        metadata = {k: v for k, v in record.items() if k != "path"}
+        metadata_json = json.dumps(metadata)
+
+        cursor = self._db.cursor()
+        cursor.execute(
+            """
+            INSERT INTO images (path, metadata) VALUES (?, ?)
+            ON CONFLICT(path) DO UPDATE SET metadata = excluded.metadata
+        """,
+            (path, metadata_json),
+        )
+
+        self._db.commit()
+
+        # Get the rowid of the inserted/updated record
+        cursor.execute("SELECT id FROM images WHERE path = ?", (path,))
+        result = cursor.fetchone()
+        if result:
+            return result[0]
+        return cursor.lastrowid if cursor.lastrowid is not None else 0
+
+    def search_image(self, conditions: dict[str, Any]) -> list[dict[str, Any]] | None:
+        """Search for images matching the given conditions.
+
+        Args:
+            conditions: Dictionary of metadata key-value pairs to match
+
+        Returns:
+            List of matching image records or None if no matches
+        """
+        cursor = self._db.cursor()
+        cursor.execute("SELECT id, path, metadata FROM images")
+
+        results = []
+        for row in cursor.fetchall():
+            metadata = json.loads(row["metadata"])
+            metadata["path"] = row["path"]
+            metadata["id"] = row["id"]
+
+            # Check if all conditions match
+            match = all(metadata.get(k) == v for k, v in conditions.items())
+            if match:
+                results.append(metadata)
+
+        return results if results else None
+
+    def search_session(
+        self, conditions: dict[str, Any] | None
+    ) -> list[dict[str, Any]] | None:
+        """Search for sessions matching the given conditions.
+
+        Args:
+            conditions: Dictionary of session key-value pairs to match, or None for all.
+                       Special keys:
+                       - 'date_start': Filter sessions starting on or after this date
+                       - 'date_end': Filter sessions starting on or before this date
+
+        Returns:
+            List of matching session records or None
+        """
+        if conditions is None:
+            return self.all_sessions()
+
+        cursor = self._db.cursor()
+        cursor.execute(
+            """
+            SELECT id, start, end, filter, imagetyp, object,
+                   num_images, exptime_total, image_doc_id
+            FROM sessions
+        """
+        )
+
+        # Extract date range conditions if present
+        date_start = conditions.get("date_start")
+        date_end = conditions.get("date_end")
+
+        # Create a copy without date range keys for standard matching
+        standard_conditions = {
+            k: v
+            for k, v in conditions.items()
+            if k not in ("date_start", "date_end") and v is not None
+        }
 
-    def get_image(self, path: str) -> table.Document | list[table.Document] | None:
-        Image = Query()
-        return self.images.get(Image.path == path)
+        results = []
+        for row in cursor.fetchall():
+            session = {
+                "id": row["id"],
+                self.START_KEY: row["start"],
+                self.END_KEY: row["end"],
+                self.FILTER_KEY: row["filter"],
+                self.IMAGETYP_KEY: row["imagetyp"],
+                self.OBJECT_KEY: row["object"],
+                self.NUM_IMAGES_KEY: row["num_images"],
+                self.EXPTIME_TOTAL_KEY: row["exptime_total"],
+                self.IMAGE_DOC_KEY: row["image_doc_id"],
+            }
+
+            # Check if all standard conditions match
+            match = all(session.get(k) == v for k, v in standard_conditions.items())
+
+            # Apply date range filtering
+            if match and date_start:
+                session_start = session.get(self.START_KEY, "")
+                match = match and session_start >= date_start
+
+            if match and date_end:
+                session_start = session.get(self.START_KEY, "")
+                match = match and session_start <= date_end
+
+            if match:
+                results.append(session)
+
+        return results if results else None
+
+    def len_session(self) -> int:
+        """Return the total number of sessions."""
+        cursor = self._db.cursor()
+        cursor.execute("SELECT COUNT(*) FROM sessions")
+        result = cursor.fetchone()
+        return result[0] if result else 0
+
+    def get_image(self, path: str) -> dict[str, Any] | None:
+        """Get an image record by path."""
+        cursor = self._db.cursor()
+        cursor.execute("SELECT id, path, metadata FROM images WHERE path = ?", (path,))
+        row = cursor.fetchone()
+
+        if row is None:
+            return None
+
+        metadata = json.loads(row["metadata"])
+        metadata["path"] = row["path"]
+        metadata["id"] = row["id"]
+        return metadata
 
     def all_images(self) -> list[dict[str, Any]]:
-        return list(self.images.all())
+        """Return all image records."""
+        cursor = self._db.cursor()
+        cursor.execute("SELECT id, path, metadata FROM images")
+
+        results = []
+        for row in cursor.fetchall():
+            metadata = json.loads(row["metadata"])
+            metadata["path"] = row["path"]
+            metadata["id"] = row["id"]
+            results.append(metadata)
+
+        return results
+
+    def all_sessions(self) -> list[dict[str, Any]]:
+        """Return all session records."""
+        cursor = self._db.cursor()
+        cursor.execute(
+            """
+            SELECT id, start, end, filter, imagetyp, object,
+                   num_images, exptime_total, image_doc_id
+            FROM sessions
+        """
+        )
+
+        results = []
+        for row in cursor.fetchall():
+            session = {
+                "id": row["id"],
+                self.START_KEY: row["start"],
+                self.END_KEY: row["end"],
+                self.FILTER_KEY: row["filter"],
+                self.IMAGETYP_KEY: row["imagetyp"],
+                self.OBJECT_KEY: row["object"],
+                self.NUM_IMAGES_KEY: row["num_images"],
+                self.EXPTIME_TOTAL_KEY: row["exptime_total"],
+                self.IMAGE_DOC_KEY: row["image_doc_id"],
+            }
+            results.append(session)
+
+        return results
+
+    def get_session(self, to_find: dict[str, str]) -> dict[str, Any] | None:
+        """Find a session matching the given criteria.
+
+        Searches for sessions with the same filter, image type, and target
+        whose start time is within +/- 8 hours of the provided date.
+        """
+        date = to_find.get(Database.START_KEY)
+        assert date
+        image_type = to_find.get(Database.IMAGETYP_KEY)
+        assert image_type
+        filter = to_find.get(Database.FILTER_KEY)
+        assert filter
+        target = to_find.get(Database.OBJECT_KEY)
+        assert target
+
+        # Convert the provided ISO8601 date string to a datetime, then
+        # search for sessions with the same filter whose start time is
+        # within +/- 8 hours of the provided date.
+        target_dt = datetime.fromisoformat(date)
+        window = timedelta(hours=8)
+        start_min = (target_dt - window).isoformat()
+        start_max = (target_dt + window).isoformat()
+
+        # Since session 'start' is stored as ISO8601 strings, lexicographic
+        # comparison aligns with chronological ordering for a uniform format.
+        cursor = self._db.cursor()
+        cursor.execute(
+            """
+            SELECT id, start, end, filter, imagetyp, object,
+                   num_images, exptime_total, image_doc_id
+            FROM sessions
+            WHERE filter = ? AND imagetyp = ? AND object = ?
+              AND start >= ? AND start <= ?
+            LIMIT 1
+        """,
+            (filter, image_type, target, start_min, start_max),
+        )
+
+        row = cursor.fetchone()
+        if row is None:
+            return None
+
+        return {
+            "id": row["id"],
+            self.START_KEY: row["start"],
+            self.END_KEY: row["end"],
+            self.FILTER_KEY: row["filter"],
+            self.IMAGETYP_KEY: row["imagetyp"],
+            self.OBJECT_KEY: row["object"],
+            self.NUM_IMAGES_KEY: row["num_images"],
+            self.EXPTIME_TOTAL_KEY: row["exptime_total"],
+            self.IMAGE_DOC_KEY: row["image_doc_id"],
+        }
+
+    def upsert_session(
+        self, new: dict[str, Any], existing: dict[str, Any] | None = None
+    ) -> None:
+        """Insert or update a session record."""
+        cursor = self._db.cursor()
+
+        if existing:
+            # Update existing session with new data
+            updated_start = min(new[Database.START_KEY], existing[Database.START_KEY])
+            updated_end = max(new[Database.END_KEY], existing[Database.END_KEY])
+            updated_num_images = existing.get(Database.NUM_IMAGES_KEY, 0) + new.get(
+                Database.NUM_IMAGES_KEY, 0
+            )
+            updated_exptime_total = existing.get(
+                Database.EXPTIME_TOTAL_KEY, 0
+            ) + new.get(Database.EXPTIME_TOTAL_KEY, 0)
+
+            cursor.execute(
+                """
+                UPDATE sessions
+                SET start = ?, end = ?, num_images = ?, exptime_total = ?
+                WHERE id = ?
+            """,
+                (
+                    updated_start,
+                    updated_end,
+                    updated_num_images,
+                    updated_exptime_total,
+                    existing["id"],
+                ),
+            )
+        else:
+            # Insert new session
+            cursor.execute(
+                """
+                INSERT INTO sessions
+                (start, end, filter, imagetyp, object, num_images, exptime_total, image_doc_id)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    new[Database.START_KEY],
+                    new[Database.END_KEY],
+                    new[Database.FILTER_KEY],
+                    new[Database.IMAGETYP_KEY],
+                    new[Database.OBJECT_KEY],
+                    new[Database.NUM_IMAGES_KEY],
+                    new[Database.EXPTIME_TOTAL_KEY],
+                    new.get(Database.IMAGE_DOC_KEY),
+                ),
+            )
+
+        self._db.commit()
 
     # --- Lifecycle ---
     def close(self) -> None:

starbash/{appdefaults.sb.toml → defaults/starbash.toml}

@@ -10,25 +10,17 @@ kind = "preferences"
 # 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]]
+# [[repo-ref]]
 # Possibly provide default repos via http from github?
 # url = "https://github.com/geeksville/starbash-default-repo"
 
-[[repo.ref]]
+[[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]]
+# [[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.
@@ -40,7 +32,7 @@ dir = "/workspaces/starbash/doc/toml/example/config/user/"
 # url = "http://fixme.com/foo-repo/somedir"
 
 # test data.  Moved to user preferences (where it should should have been all along)
-# [[repo.ref]]
+# [[repo-ref]]
 # dir = "~/Pictures/telescope/from_astroboy"
 
 
@@ -48,7 +40,7 @@ dir = "/workspaces/starbash/doc/toml/example/config/user/"
 
 
 # allow including multiple recipies FIXME old idea, not sure if needed.
-# [[repo.ref]]
+# [[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
@@ -67,7 +59,7 @@ fits-whitelist = [
     "DATE-OBS",
     "DATE-LOC",
     "DATE",
-    "EXPTIME",
+    "EXPTIME",  # Use use this instead of EXPOSURE because it seems like not all apps use EXPOSURE (Siril)
     "FWHEEL",
     "OBJECT",
     "RA",       # we ignore the text version OBJCTRA / OBJCTDEC

starbash/main.py

@@ -1,26 +1,149 @@
 import logging
+from datetime import datetime
+from tomlkit import table
 import typer
+from rich.table import Table
 
-from .app import AstroGlue
-from .commands import repo
+from starbash.database import Database
+import starbash.url as url
 
-app = typer.Typer()
+from .app import Starbash
+from .commands import repo, user, selection
+from . import console
+
+app = typer.Typer(
+    rich_markup_mode="rich",
+    help=f"Starbash - Astrophotography workflows simplified.\n\nFor full instructions and support [link={url.project}]click here[/link].",
+)
+app.add_typer(user.app, name="user", help="Manage user settings.")
 app.add_typer(repo.app, name="repo", help="Manage Starbash repositories.")
+app.add_typer(
+    selection.app, name="selection", help="Manage session and target selection."
+)
+
 
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context):
+    """Main callback for the Starbash application."""
+    if ctx.invoked_subcommand is None:
+        # No command provided, show help
+        console.print(ctx.get_help())
+        raise typer.Exit()
 
-@app.command(hidden=True)
-def default_cmd():
-    """Default entry point for the starbash application."""
 
-    with AstroGlue() as ag:
-        pass
+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.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()
+@app.command()
+def session():
+    """List sessions (filtered based on the current selection)"""
+
+    with Starbash("session") 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})")
+
+            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(
+                "About", style="cyan", no_wrap=True
+            )  # type of frames, filter, target
+            # table.add_column("Released", justify="right", style="cyan", no_wrap=True)
+
+            total_images = 0
+            total_seconds = 0.0
+
+            for sess in sessions:
+                date_iso = sess.get(Database.START_KEY, "N/A")
+                # Try to cnvert 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")
+                image_type = str(sess.get(Database.IMAGETYP_KEY, "N/A"))
+
+                # 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
+                if image_type.upper() == "FLAT":
+                    image_type = f"{image_type}/{filter}"
+
+                table.add_row(
+                    date,
+                    str(num_images),
+                    total_secs,
+                    image_type,
+                    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)
+
+
+# @app.command(hidden=True)
+# def default_cmd():
+#    """Default entry point for the starbash application."""
+#
+#    with Starbash() as sb:
+
+
+# @app.command(hidden=True)
+# def default_cmd():
+#    """Default entry point for the starbash application."""
+#
+#    with Starbash() as sb:
+#        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__":

starbash/paths.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+from platformdirs import PlatformDirs
+
+app_name = "starbash"
+app_author = "geeksville"
+dirs = PlatformDirs(app_name, app_author)
+config_dir = Path(dirs.user_config_dir)
+data_dir = Path(dirs.user_data_dir)
+
+# These can be overridden for testing
+_override_config_dir: Path | None = None
+_override_data_dir: Path | None = None
+
+
+def set_test_directories(
+    config_dir_override: Path | None = None, data_dir_override: Path | None = None
+) -> None:
+    """Set override directories for testing. Used by test fixtures to isolate test data."""
+    global _override_config_dir, _override_data_dir
+    _override_config_dir = config_dir_override
+    _override_data_dir = data_dir_override
+
+
+def get_user_config_dir() -> Path:
+    """Get the user config directory. Returns test override if set, otherwise the real user directory."""
+    dir_to_use = (
+        _override_config_dir if _override_config_dir is not None else config_dir
+    )
+    os.makedirs(dir_to_use, exist_ok=True)
+    return dir_to_use
+
+
+def get_user_data_dir() -> Path:
+    """Get the user data directory. Returns test override if set, otherwise the real user directory."""
+    dir_to_use = _override_data_dir if _override_data_dir is not None else data_dir
+    os.makedirs(dir_to_use, exist_ok=True)
+    return dir_to_use