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

starbash/database.py

@@ -15,6 +15,9 @@ class Database:
 
     Stores data under the OS-specific user data directory using platformdirs.
     Provides an `images` table for FITS metadata and basic helpers.
+
+    The images table stores DATE-OBS and DATE as indexed SQL columns for
+    efficient date-based queries, while other FITS metadata is stored in JSON.
     """
 
     EXPTIME_KEY = "EXPTIME"
@@ -24,9 +27,11 @@ class Database:
     NUM_IMAGES_KEY = "num-images"
     EXPTIME_TOTAL_KEY = "exptime-total"
     DATE_OBS_KEY = "DATE-OBS"
+    DATE_KEY = "DATE"
     IMAGE_DOC_KEY = "image-doc"
     IMAGETYP_KEY = "IMAGETYP"
     OBJECT_KEY = "OBJECT"
+    TELESCOP_KEY = "TELESCOP"
 
     def __init__(
         self,
@@ -52,12 +57,14 @@ class Database:
         """Create the images and sessions tables if they don't exist."""
         cursor = self._db.cursor()
 
-        # Create images table
+        # Create images table with DATE-OBS and DATE as indexed columns
         cursor.execute(
             """
             CREATE TABLE IF NOT EXISTS images (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 path TEXT UNIQUE NOT NULL,
+                date_obs TEXT,
+                date TEXT,
                 metadata TEXT NOT NULL
             )
         """
@@ -70,6 +77,20 @@ class Database:
         """
         )
 
+        # Create index on date_obs for efficient date range queries
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_images_date_obs ON images(date_obs)
+        """
+        )
+
+        # Create index on date for queries using DATE field
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_images_date ON images(date)
+        """
+        )
+
         # Create sessions table
         cursor.execute(
             """
@@ -80,6 +101,7 @@ class Database:
                 filter TEXT NOT NULL,
                 imagetyp TEXT NOT NULL,
                 object TEXT NOT NULL,
+                telescop TEXT NOT NULL,
                 num_images INTEGER NOT NULL,
                 exptime_total REAL NOT NULL,
                 image_doc_id INTEGER
@@ -91,7 +113,7 @@ class Database:
         cursor.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_sessions_lookup
-            ON sessions(filter, imagetyp, object, start, end)
+            ON sessions(filter, imagetyp, object, telescop, start, end)
         """
         )
 
@@ -102,23 +124,31 @@ class Database:
         """Insert or update an image record by unique path.
 
         The record must include a 'path' key; other keys are arbitrary FITS metadata.
+        DATE-OBS and DATE are extracted and stored as indexed columns for efficient queries.
         Returns the rowid of the inserted/updated record.
         """
         path = record.get("path")
         if not path:
             raise ValueError("record must include 'path'")
 
-        # Separate path from metadata
+        # Extract date fields for column storage
+        date_obs = record.get(self.DATE_OBS_KEY)
+        date = record.get(self.DATE_KEY)
+
+        # Separate path and date fields 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
+            INSERT INTO images (path, date_obs, date, metadata) VALUES (?, ?, ?, ?)
+            ON CONFLICT(path) DO UPDATE SET
+                date_obs = excluded.date_obs,
+                date = excluded.date,
+                metadata = excluded.metadata
         """,
-            (path, metadata_json),
+            (path, date_obs, date, metadata_json),
         )
 
         self._db.commit()
@@ -134,13 +164,38 @@ class Database:
         """Search for images matching the given conditions.
 
         Args:
-            conditions: Dictionary of metadata key-value pairs to match
+            conditions: Dictionary of metadata key-value pairs to match.
+                       Special keys:
+                       - 'date_start': Filter images with DATE-OBS >= this date
+                       - 'date_end': Filter images with DATE-OBS <= this date
 
         Returns:
             List of matching image records or None if no matches
         """
+        # Extract special date filter keys (make a copy to avoid modifying caller's dict)
+        conditions_copy = dict(conditions)
+        date_start = conditions_copy.pop("date_start", None)
+        date_end = conditions_copy.pop("date_end", None)
+
+        # Build SQL query with WHERE clauses for date filtering
+        where_clauses = []
+        params = []
+
+        if date_start:
+            where_clauses.append("date_obs >= ?")
+            params.append(date_start)
+
+        if date_end:
+            where_clauses.append("date_obs <= ?")
+            params.append(date_end)
+
+        # Build the query
+        query = "SELECT id, path, date_obs, date, metadata FROM images"
+        if where_clauses:
+            query += " WHERE " + " AND ".join(where_clauses)
+
         cursor = self._db.cursor()
-        cursor.execute("SELECT id, path, metadata FROM images")
+        cursor.execute(query, params)
 
         results = []
         for row in cursor.fetchall():
@@ -148,8 +203,15 @@ class Database:
             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())
+            # Add date fields back to metadata for compatibility
+            if row["date_obs"]:
+                metadata[self.DATE_OBS_KEY] = row["date_obs"]
+            if row["date"]:
+                metadata[self.DATE_KEY] = row["date"]
+
+            # Check if remaining conditions match (those stored in JSON metadata)
+            match = all(metadata.get(k) == v for k, v in conditions_copy.items())
+
             if match:
                 results.append(metadata)
 
@@ -175,7 +237,7 @@ class Database:
         cursor = self._db.cursor()
         cursor.execute(
             """
-            SELECT id, start, end, filter, imagetyp, object,
+            SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
             FROM sessions
         """
@@ -201,6 +263,7 @@ class Database:
                 self.FILTER_KEY: row["filter"],
                 self.IMAGETYP_KEY: row["imagetyp"],
                 self.OBJECT_KEY: row["object"],
+                self.TELESCOP_KEY: row["telescop"],
                 self.NUM_IMAGES_KEY: row["num_images"],
                 self.EXPTIME_TOTAL_KEY: row["exptime_total"],
                 self.IMAGE_DOC_KEY: row["image_doc_id"],
@@ -230,10 +293,24 @@ class Database:
         result = cursor.fetchone()
         return result[0] if result else 0
 
+    def get_column(self, column_name: str, table_name: str = "sessions") -> list[Any]:
+        """Return all values from a specific column in the specified table."""
+        cursor = self._db.cursor()
+        cursor.execute(f"SELECT {column_name} FROM {table_name}")
+
+        results = []
+        for row in cursor.fetchall():
+            results.append(row[column_name])
+
+        return results
+
     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,))
+        cursor.execute(
+            "SELECT id, path, date_obs, date, metadata FROM images WHERE path = ?",
+            (path,),
+        )
         row = cursor.fetchone()
 
         if row is None:
@@ -242,18 +319,32 @@ class Database:
         metadata = json.loads(row["metadata"])
         metadata["path"] = row["path"]
         metadata["id"] = row["id"]
+
+        # Add date fields back to metadata for compatibility
+        if row["date_obs"]:
+            metadata[self.DATE_OBS_KEY] = row["date_obs"]
+        if row["date"]:
+            metadata[self.DATE_KEY] = row["date"]
+
         return metadata
 
     def all_images(self) -> list[dict[str, Any]]:
         """Return all image records."""
         cursor = self._db.cursor()
-        cursor.execute("SELECT id, path, metadata FROM images")
+        cursor.execute("SELECT id, path, date_obs, date, metadata FROM images")
 
         results = []
         for row in cursor.fetchall():
             metadata = json.loads(row["metadata"])
             metadata["path"] = row["path"]
             metadata["id"] = row["id"]
+
+            # Add date fields back to metadata for compatibility
+            if row["date_obs"]:
+                metadata[self.DATE_OBS_KEY] = row["date_obs"]
+            if row["date"]:
+                metadata[self.DATE_KEY] = row["date"]
+
             results.append(metadata)
 
         return results
@@ -263,7 +354,7 @@ class Database:
         cursor = self._db.cursor()
         cursor.execute(
             """
-            SELECT id, start, end, filter, imagetyp, object,
+            SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
             FROM sessions
         """
@@ -278,6 +369,7 @@ class Database:
                 self.FILTER_KEY: row["filter"],
                 self.IMAGETYP_KEY: row["imagetyp"],
                 self.OBJECT_KEY: row["object"],
+                self.TELESCOP_KEY: row["telescop"],
                 self.NUM_IMAGES_KEY: row["num_images"],
                 self.EXPTIME_TOTAL_KEY: row["exptime_total"],
                 self.IMAGE_DOC_KEY: row["image_doc_id"],
@@ -286,10 +378,47 @@ class Database:
 
         return results
 
+    def get_session_by_id(self, session_id: int) -> dict[str, Any] | None:
+        """Get a session record by its ID.
+
+        Args:
+            session_id: The database ID of the session
+
+        Returns:
+            Session record dictionary or None if not found
+        """
+        cursor = self._db.cursor()
+        cursor.execute(
+            """
+            SELECT id, start, end, filter, imagetyp, object, telescop,
+                   num_images, exptime_total, image_doc_id
+            FROM sessions
+            WHERE id = ?
+        """,
+            (session_id,),
+        )
+
+        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.TELESCOP_KEY: row["telescop"],
+            self.NUM_IMAGES_KEY: row["num_images"],
+            self.EXPTIME_TOTAL_KEY: row["exptime_total"],
+            self.IMAGE_DOC_KEY: row["image_doc_id"],
+        }
+
     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
+        Searches for sessions with the same filter, image type, target, and telescope
         whose start time is within +/- 8 hours of the provided date.
         """
         date = to_find.get(Database.START_KEY)
@@ -300,6 +429,7 @@ class Database:
         assert filter
         target = to_find.get(Database.OBJECT_KEY)
         assert target
+        telescop = to_find.get(Database.TELESCOP_KEY, "unspecified")
 
         # Convert the provided ISO8601 date string to a datetime, then
         # search for sessions with the same filter whose start time is
@@ -314,14 +444,14 @@ class Database:
         cursor = self._db.cursor()
         cursor.execute(
             """
-            SELECT id, start, end, filter, imagetyp, object,
+            SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
             FROM sessions
-            WHERE filter = ? AND imagetyp = ? AND object = ?
+            WHERE filter = ? AND imagetyp = ? AND object = ? AND telescop = ?
               AND start >= ? AND start <= ?
             LIMIT 1
         """,
-            (filter, image_type, target, start_min, start_max),
+            (filter, image_type, target, telescop, start_min, start_max),
         )
 
         row = cursor.fetchone()
@@ -335,6 +465,7 @@ class Database:
             self.FILTER_KEY: row["filter"],
             self.IMAGETYP_KEY: row["imagetyp"],
             self.OBJECT_KEY: row["object"],
+            self.TELESCOP_KEY: row["telescop"],
             self.NUM_IMAGES_KEY: row["num_images"],
             self.EXPTIME_TOTAL_KEY: row["exptime_total"],
             self.IMAGE_DOC_KEY: row["image_doc_id"],
@@ -376,8 +507,8 @@ class Database:
             cursor.execute(
                 """
                 INSERT INTO sessions
-                (start, end, filter, imagetyp, object, num_images, exptime_total, image_doc_id)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (start, end, filter, imagetyp, object, telescop, num_images, exptime_total, image_doc_id)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
                 (
                     new[Database.START_KEY],
@@ -385,6 +516,7 @@ class Database:
                     new[Database.FILTER_KEY],
                     new[Database.IMAGETYP_KEY],
                     new[Database.OBJECT_KEY],
+                    new.get(Database.TELESCOP_KEY, "unspecified"),
                     new[Database.NUM_IMAGES_KEY],
                     new[Database.EXPTIME_TOTAL_KEY],
                     new.get(Database.IMAGE_DOC_KEY),

starbash/defaults/starbash.toml

@@ -18,7 +18,7 @@ kind = "preferences"
 
 # 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"
+url = "pkg://recipes"
 
 # [[repo-ref]]
 
@@ -39,7 +39,7 @@ dir = "/workspaces/starbash/doc/toml/example/recipe-repo"
 # or inband?
 
 
-# allow including multiple recipies FIXME old idea, not sure if needed.
+# allow including multiple recipes 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
@@ -47,35 +47,3 @@ dir = "/workspaces/starbash/doc/toml/example/recipe-repo"
 # 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",  # 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
-    "DEC",
-    "OBJCTROT",
-    "FOCPOS",
-    "SITELAT",
-    "SITELON",
-    "SITEELEV",
-    "NAXIS1",
-    "NAXIS2",
-    "SWCREATE",
-    "XBINNING",
-    "YBINNING",
-    "GAIN",
-    "CCD-TEMP",
-    "SET-TEMP",
-    "AMBTEMP",
-]

starbash/main.py

@@ -1,14 +1,12 @@
 import logging
-from datetime import datetime
-from tomlkit import table
 import typer
-from rich.table import Table
+from typing_extensions import Annotated
 
-from starbash.database import Database
 import starbash.url as url
+import starbash
 
-from .app import Starbash
-from .commands import repo, user, selection
+from .app import Starbash, get_user_config_path, setup_logging
+from .commands import repo, select, user
 from . import console
 
 app = typer.Typer(
@@ -17,134 +15,34 @@ app = typer.Typer(
 )
 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.add_typer(select.app, name="select", help="Manage session and target selection.")
 
 
 @app.callback(invoke_without_command=True)
-def main_callback(ctx: typer.Context):
+def main_callback(
+    ctx: typer.Context,
+    debug: Annotated[
+        bool,
+        typer.Option(
+            "--debug",
+            help="Enable debug logging output.",
+        ),
+    ] = False,
+):
     """Main callback for the Starbash application."""
+    # Set the log level based on --debug flag
+    if debug:
+        starbash.log_filter_level = logging.DEBUG
+
     if ctx.invoked_subcommand is None:
-        # No command provided, show help
-        console.print(ctx.get_help())
+        if not get_user_config_path().exists():
+            with Starbash("app.first") as sb:
+                user.do_reinit(sb)
+        else:
+            # No command provided, show help
+            console.print(ctx.get_help())
         raise typer.Exit()
 
 
-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.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__":
     app()

starbash/recipes/README.md

@@ -0,0 +1,3 @@
+This is what a typical directory of recipes would look like.  it could be hosted locally in a directory tree, on github, whatever.
+
+Currently it lives in the starbash python blob, but eventually the 'master' set of recipes will live in a different repo.  In fact, different orgs could provide their own recipe repos.

starbash/recipes/master_bias/starbash.toml

@@ -0,0 +1,55 @@
+
+[repo]
+kind = "recipe"
+
+
+[recipe]
+author.name = "FIXMESiril?"
+author.email = "FIXMESiril?"
+
+[[stage]]
+
+description = "Generate master bias"
+disabled = true # FIXME, debugging later stuff
+
+# Restrict processing of this stage to only if detected hardware was found for this session
+# For any camera
+auto.for-camera = []
+
+tool = "siril"
+
+# or auto?
+# find the most recent raw fits for the current instrument (as of the time of session start)
+# input.source = "most-recent" # only look for the most recent set of raws for this particular type
+input.type = "bias" # look in all raw repos, but look only for bias files
+
+# for early development we have support for simple absolute file paths with globs
+input.source = "path"
+input.path = "/workspaces/starbash/images/from_astroboy/masters-raw/2025-09-09/BIAS/*.fit*"
+input.required = true # Is at least one input file required?  If true, we will skip running this stage entirely (with a warning)
+
+# make the following also work
+#
+#os.makedirs(os.path.dirname(output), exist_ok=True)
+#os.makedirs(os.path.dirname(process_dir), exist_ok=True)
+#frames = glob(f"{masters_raw}/{date}/BIAS/{date}_*.fit*")
+#siril_run_in_temp_dir(frames, ...
+when = "session-config" # run at the start of each session process
+
+# The following constants are auto defined before running the tool
+# context.process_dir (points to the session specific semi-persistent local dir for that sessions written/read data files)
+# context.masters (FIXME) - need to find this name dynamically by looking for a suitable writable repo
+# context.temp_dir (points to a temporary directory this tool can use for writing)
+
+# Everything in the constants dict will be predefined as named variables for use by the script
+context.date = "2025-09-09"  # FIXME - later find auto latest date with bias frames
+context.output = "{masters}/biases/{date}_stacked.fits" # if the output already exists processing will be skipped
+
+script = '''
+    # Convert Bias Frames to .fit files
+    link bias -out={process_dir}
+    cd {process_dir}
+
+    # Stack Bias Frames to bias_stacked.fit
+    stack bias rej 3 3 -nonorm -out={output}
+    '''