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

starbash/commands/user.py

@@ -3,6 +3,7 @@ from typing_extensions import Annotated
 
 from starbash.app import Starbash
 from starbash import console
+from rich.panel import Panel
 
 app = typer.Typer()
 
@@ -19,9 +20,9 @@ def analytics(
     """
     Enable or disable analytics (crash reports and usage data).
     """
-    with Starbash("analytics-enable") as sb:
+    with Starbash("analytics.change") as sb:
         sb.analytics.set_data("analytics.enabled", enable)
-        sb.user_repo.config["analytics.enabled"] = enable
+        sb.user_repo.set("analytics.enabled", enable)
         sb.user_repo.write_config()
         status = "enabled" if enable else "disabled"
         console.print(f"Analytics (crash reports) {status}.")
@@ -39,8 +40,8 @@ def name(
     """
     Set your name for attribution in generated images.
     """
-    with Starbash("user-name") as sb:
-        sb.user_repo.config["user.name"] = user_name
+    with Starbash("user.name") as sb:
+        sb.user_repo.set("user.name", user_name)
         sb.user_repo.write_config()
         console.print(f"User name set to: {user_name}")
 
@@ -57,7 +58,91 @@ def email(
     """
     Set your email for attribution in generated images.
     """
-    with Starbash("user-email") as sb:
-        sb.user_repo.config["user.email"] = user_email
+    with Starbash("user.email") as sb:
+        sb.user_repo.set("user.email", user_email)
         sb.user_repo.write_config()
         console.print(f"User email set to: {user_email}")
+
+
+def do_reinit(sb: Starbash) -> None:
+    console.print()
+    console.print(
+        Panel.fit(
+            "[bold cyan]Starbash getting started...[/bold cyan]\n\n"
+            "Let's set up your preferences. You can skip any question by pressing Enter.",
+            border_style="cyan",
+        )
+    )
+    console.print()
+
+    # Ask for username
+    user_name = typer.prompt(
+        "Enter your name (for attribution in generated images)",
+        default="",
+        show_default=False,
+    )
+    sb.analytics.set_data("analytics.use_name", user_name != "")
+    if user_name:
+        sb.user_repo.set("user.name", user_name)
+        console.print(f"✅ Name set to: {user_name}")
+    else:
+        console.print("[dim]Skipped name[/dim]")
+
+    # Ask for email
+    user_email = typer.prompt(
+        "Enter your email address (for attribution in generated images)",
+        default="",
+        show_default=False,
+    )
+    sb.analytics.set_data("analytics.use_email", user_email != "")
+    if user_email:
+        sb.user_repo.set("user.email", user_email)
+        console.print(f"✅ Email set to: {user_email}")
+    else:
+        console.print("[dim]Skipped email[/dim]")
+
+    # Ask about including email in crash reports
+    include_in_reports = typer.confirm(
+        "Would you like to include your email address with crash reports/analytics? "
+        "(This helps us follow up if we need more information about issues.)",
+        default=False,
+    )
+    sb.analytics.set_data("analytics.use_email_report", include_in_reports)
+    sb.user_repo.set("analytics.include_user", include_in_reports)
+    if include_in_reports:
+        console.print("✅ Email will be included with crash reports")
+    else:
+        console.print("❌ Email will NOT be included with crash reports")
+    console.print()
+
+    # Save all changes
+    sb.user_repo.write_config()
+
+    console.print(
+        Panel.fit(
+            "[bold green]Configuration complete![/bold green]\n\n"
+            "Your preferences have been saved.",
+            border_style="green",
+        )
+    )
+
+
+@app.command()
+def reinit():
+    """
+    Configure starbash via a brief guided process.
+
+    This will ask you for your name, email, and analytics preferences.
+    You can skip any question by pressing Enter.
+    """
+    with Starbash("user.reinit") as sb:
+        do_reinit(sb)
+
+
+@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()

starbash/database.py

@@ -33,6 +33,9 @@ class Database:
     OBJECT_KEY = "OBJECT"
     TELESCOP_KEY = "TELESCOP"
 
+    SESSIONS_TABLE = "sessions"
+    IMAGES_TABLE = "images"
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -59,8 +62,8 @@ class Database:
 
         # Create images table with DATE-OBS and DATE as indexed columns
         cursor.execute(
-            """
-            CREATE TABLE IF NOT EXISTS images (
+            f"""
+            CREATE TABLE IF NOT EXISTS {self.IMAGES_TABLE} (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 path TEXT UNIQUE NOT NULL,
                 date_obs TEXT,
@@ -72,29 +75,29 @@ class Database:
 
         # Create index on path for faster lookups
         cursor.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_images_path ON images(path)
+            f"""
+            CREATE INDEX IF NOT EXISTS idx_images_path ON {self.IMAGES_TABLE}(path)
         """
         )
 
         # 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)
+            f"""
+            CREATE INDEX IF NOT EXISTS idx_images_date_obs ON {self.IMAGES_TABLE}(date_obs)
         """
         )
 
         # Create index on date for queries using DATE field
         cursor.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_images_date ON images(date)
+            f"""
+            CREATE INDEX IF NOT EXISTS idx_images_date ON {self.IMAGES_TABLE}(date)
         """
         )
 
         # Create sessions table
         cursor.execute(
-            """
-            CREATE TABLE IF NOT EXISTS sessions (
+            f"""
+            CREATE TABLE IF NOT EXISTS {self.SESSIONS_TABLE} (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 start TEXT NOT NULL,
                 end TEXT NOT NULL,
@@ -111,9 +114,9 @@ class Database:
 
         # Create index on session attributes for faster queries
         cursor.execute(
-            """
+            f"""
             CREATE INDEX IF NOT EXISTS idx_sessions_lookup
-            ON sessions(filter, imagetyp, object, telescop, start, end)
+            ON {self.SESSIONS_TABLE}(filter, imagetyp, object, telescop, start, end)
         """
         )
 
@@ -141,8 +144,8 @@ class Database:
 
         cursor = self._db.cursor()
         cursor.execute(
-            """
-            INSERT INTO images (path, date_obs, date, metadata) VALUES (?, ?, ?, ?)
+            f"""
+            INSERT INTO {self.IMAGES_TABLE} (path, date_obs, date, metadata) VALUES (?, ?, ?, ?)
             ON CONFLICT(path) DO UPDATE SET
                 date_obs = excluded.date_obs,
                 date = excluded.date,
@@ -154,7 +157,7 @@ class Database:
         self._db.commit()
 
         # Get the rowid of the inserted/updated record
-        cursor.execute("SELECT id FROM images WHERE path = ?", (path,))
+        cursor.execute(f"SELECT id FROM {self.IMAGES_TABLE} WHERE path = ?", (path,))
         result = cursor.fetchone()
         if result:
             return result[0]
@@ -190,7 +193,7 @@ class Database:
             params.append(date_end)
 
         # Build the query
-        query = "SELECT id, path, date_obs, date, metadata FROM images"
+        query = f"SELECT id, path, date_obs, date, metadata FROM {self.IMAGES_TABLE}"
         if where_clauses:
             query += " WHERE " + " AND ".join(where_clauses)
 
@@ -236,10 +239,10 @@ class Database:
 
         cursor = self._db.cursor()
         cursor.execute(
-            """
+            f"""
             SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
-            FROM sessions
+            FROM {self.SESSIONS_TABLE}
         """
         )
 
@@ -286,18 +289,36 @@ class Database:
 
         return results if results else None
 
-    def len_session(self) -> int:
-        """Return the total number of sessions."""
+    def len_table(self, table_name: str) -> int:
+        """Return the total number of rows in the specified table."""
         cursor = self._db.cursor()
-        cursor.execute("SELECT COUNT(*) FROM sessions")
+        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
         result = cursor.fetchone()
         return result[0] if result else 0
 
+    def get_column(self, table_name: str, column_name: str) -> 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 sum_column(self, table_name: str, column_name: str) -> float:
+        """Return the SUM of all values in a specific column in the specified table."""
+        cursor = self._db.cursor()
+        cursor.execute(f'SELECT SUM("{column_name}") FROM {table_name}')
+        result = cursor.fetchone()
+        return result[0] if result and result[0] is not None 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, date_obs, date, metadata FROM images WHERE path = ?",
+            f"SELECT id, path, date_obs, date, metadata FROM {self.IMAGES_TABLE} WHERE path = ?",
             (path,),
         )
         row = cursor.fetchone()
@@ -320,7 +341,9 @@ class Database:
     def all_images(self) -> list[dict[str, Any]]:
         """Return all image records."""
         cursor = self._db.cursor()
-        cursor.execute("SELECT id, path, date_obs, date, metadata FROM images")
+        cursor.execute(
+            f"SELECT id, path, date_obs, date, metadata FROM {self.IMAGES_TABLE}"
+        )
 
         results = []
         for row in cursor.fetchall():
@@ -342,10 +365,10 @@ class Database:
         """Return all session records."""
         cursor = self._db.cursor()
         cursor.execute(
-            """
+            f"""
             SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
-            FROM sessions
+            FROM {self.SESSIONS_TABLE}
         """
         )
 
@@ -378,10 +401,10 @@ class Database:
         """
         cursor = self._db.cursor()
         cursor.execute(
-            """
+            f"""
             SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
-            FROM sessions
+            FROM {self.SESSIONS_TABLE}
             WHERE id = ?
         """,
             (session_id,),
@@ -432,10 +455,10 @@ class Database:
         # comparison aligns with chronological ordering for a uniform format.
         cursor = self._db.cursor()
         cursor.execute(
-            """
+            f"""
             SELECT id, start, end, filter, imagetyp, object, telescop,
                    num_images, exptime_total, image_doc_id
-            FROM sessions
+            FROM {self.SESSIONS_TABLE}
             WHERE filter = ? AND imagetyp = ? AND object = ? AND telescop = ?
               AND start >= ? AND start <= ?
             LIMIT 1
@@ -478,8 +501,8 @@ class Database:
             ) + new.get(Database.EXPTIME_TOTAL_KEY, 0)
 
             cursor.execute(
-                """
-                UPDATE sessions
+                f"""
+                UPDATE {self.SESSIONS_TABLE}
                 SET start = ?, end = ?, num_images = ?, exptime_total = ?
                 WHERE id = ?
             """,
@@ -494,8 +517,8 @@ class Database:
         else:
             # Insert new session
             cursor.execute(
-                """
-                INSERT INTO sessions
+                f"""
+                INSERT INTO {self.SESSIONS_TABLE}
                 (start, end, filter, imagetyp, object, telescop, num_images, exptime_total, image_doc_id)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,

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

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 info, repo, select, user
 from . import console
 
 app = typer.Typer(
@@ -17,140 +15,35 @@ 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.add_typer(info.app, name="info", help="Display system and data information.")
 
 
 @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("Telescope", 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"))
-                telescop = str(sess.get(Database.TELESCOP_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
-                elif image_type.upper() == "FLAT":
-                    image_type = f"{image_type}/{filter}"
-                else:  # either bias or dark
-                    object = ""  # Don't show meaningless target
-
-                table.add_row(
-                    date,
-                    str(num_images),
-                    total_secs,
-                    image_type,
-                    telescop,
-                    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}
+    '''

starbash/recipes/master_flat/starbash.toml

@@ -0,0 +1,46 @@
+
+[repo]
+kind = "recipe"
+
+
+[recipe]
+author.name = "FIXMESiril?"
+author.email = "FIXMESiril?"
+
+
+[[stage]]
+
+description = "Generate master flat"
+disabled = true # FIXME, debugging later stuff
+
+# For any camera
+auto.for-camera = []
+
+tool = "siril"
+# input.source = "session" # or auto? prefer ones in session otherwise find by in masters
+input.type = "flat" # look in _session_ directories, but look only for flat files
+
+# FIXME for early development we have support for simple absolute file paths with globs
+input.source = "path"
+input.path = "/workspaces/starbash/images/from_astroboy/M 27/2025-09-16/FLAT/*.fit*"
+input.required = true # Is at least one input file required?  If true, we will skip running this stage entirely (with a warning)
+
+when = "session-config" # run once per session-config
+context.output = "{process_dir}/flat_s{sessionid}_c{sessionconfig}.fits"
+
+# FIXME, bias should have been added to context by two previous stages.  But for now hardwire
+context.bias = '/workspaces/starbash/images/masters/biases/2025-09-09_stacked.fits'
+
+script = '''
+    # Create a sequence from the raw flat frames
+    link flat -out={process_dir}
+    cd {process_dir}
+
+    # Calibrate the flat frames using master bias
+    calibrate flat -bias={bias}
+
+    # Stack the pre-processed (calibrated) flat frames (writes to flat_stacked.fit)
+    stack pp_flat rej 3 3 -norm=mul -out=flat_stacked
+    '''
+
+temporaries = ["flat", "pp_flat"]