starbash 0.1.3__py3-none-any.whl → 0.1.4__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

@@ -293,6 +293,17 @@ 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()

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 repo, select, user
 from . import console
 
 app = typer.Typer(
@@ -17,140 +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("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"]

starbash/recipes/osc_dual_duo/starbash.py

@@ -0,0 +1,151 @@
+# pyright: reportUndefinedVariable=false
+# ('context' and 'logger' are injected by the starbash runtime)
+
+import os
+from glob import glob
+from starbash.tool import tools
+
+siril = tools["siril"]
+
+delete_temps = False
+
+
+# FIXME move this into main starbash
+def perhaps_delete_temps(temps: list[str]) -> None:
+    if delete_temps:
+        for t in temps:
+            for path in glob(f"{context['process_dir']}/{t}_*"):
+                os.remove(path)
+
+
+def normalize_target_name(name: str) -> str:
+    """Converts a target name to an any filesystem-safe format by removing spaces"""
+    return name.replace(" ", "").upper()
+
+
+def make_stacked(sessionconfig: str, variant: str, output_file: str):
+    """
+    Registers and stacks all pre-processed light frames for a given filter configuration
+    across all sessions.
+    """
+    # The sequence name for all frames of this variant across all sessions
+    # e.g. Ha_bkg_pp_light_cHaOiii
+    merged_seq_base = f"all_{variant}_bkg_pp_light"
+
+    # Absolute path for the output stacked file
+    stacked_output_path = glob(f"{context["process_dir"]}/{output_file}.fit*")
+
+    if stacked_output_path:
+        logger.info(f"Using existing stacked file: {stacked_output_path}")
+    else:
+        # Merge all frames (from multiple sessions and configs) use those for stacking
+        frames = glob(
+            f"{context["process_dir"]}/{variant}_bkg_pp_light_s*_c{sessionconfig}_*.fit*"
+        )
+
+        logger.info(
+            f"Registering and stacking {len(frames)} frames for {sessionconfig}/{variant} -> {stacked_output_path}"
+        )
+
+        # Siril commands for registration and stacking. We run this in process_dir.
+        commands = f"""
+            link {merged_seq_base} -out={context["process_dir"]}
+            cd {context["process_dir"]}
+
+            register {merged_seq_base}
+            stack r_{merged_seq_base} rej g 0.3 0.05 -filter-wfwhm=3k -norm=addscale -output_norm -32b -out={output_file}
+
+            # and flip if required
+            mirrorx_single {output_file}
+            """
+
+        context["input_files"] = frames
+        siril.run_in_temp_dir(commands, context=context)
+
+    perhaps_delete_temps([merged_seq_base, f"r_{merged_seq_base}"])
+
+
+def make_renormalize():
+    """
+    Aligns the stacked images (Sii, Ha, OIII) and renormalizes Sii and OIII
+    to match the flux of the Ha channel.
+    """
+    logger.info("Aligning and renormalizing stacked images.")
+
+    # Define file basenames for the stacked images created in the 'process' directory
+    ha_base = "results_00001"
+    oiii_base = "results_00002"
+    sii_base = "results_00003"
+
+    # Define final output paths. The 'results' directory is a symlink in the work dir.
+    results_dir = f"{context["targets"]}/{normalize_target_name(context["target"])}"
+    os.makedirs(results_dir, exist_ok=True)
+
+    ha_final_path = f"{results_dir}/stacked_Ha.fits"
+    oiii_final_path = f"{results_dir}/stacked_OIII.fits"
+
+    # Check if final files already exist to allow resuming
+    if all(os.path.exists(f) for f in [ha_final_path, oiii_final_path]):
+        logger.info("Renormalized files already exist, skipping.")
+        return
+
+    # Basenames for registered files (output of 'register' command)
+    r_ha = f"r_{ha_base}"
+    r_oiii = f"r_{oiii_base}"
+
+    # Pixel math formula for renormalization.
+    # It matches the median and spread (MAD) of a channel to a reference channel (Ha).
+    # Formula: new = old * (MAD(ref)/MAD(old)) - (MAD(ref)/MAD(old)) * MEDIAN(old) + MEDIAN(ref)
+    pm_oiii = f'"${r_oiii}$*mad(${r_ha}$)/mad(${r_oiii}$)-mad(${r_ha}$)/mad(${r_oiii}$)*median(${r_oiii}$)+median(${r_ha}$)"'
+
+    # Siril commands to be executed in the 'process' directory
+    commands = f"""
+        # -transf=shift fails sometimes, which I guess is possible because we have multiple sessions with possible different camera rotation
+        # -interp=none also fails sometimes, so let default interp happen
+        register results
+        pm {pm_oiii}
+        update_key FILTER Oiii "OSC dual Duo filter extracted"
+        save "{oiii_final_path}"
+        load {r_ha}
+        update_key FILTER Ha "OSC dual Duo filter extracted"
+        save "{ha_final_path}"
+        """
+
+    if os.path.exists(f"{results_dir}/{sii_base}.fit"):
+        logger.info(f"Doing renormalisation of extra Sii channel")
+
+        sii_final_path = f"{results_dir}/stacked_Sii.fits"
+        r_sii = f"r_{sii_base}"
+        pm_sii = f'"${r_sii}$*mad(${r_ha}$)/mad(${r_sii}$)-mad(${r_ha}$)/mad(${r_sii}$)*median(${r_sii}$)+median(${r_ha}$)"'
+        commands += f"""
+            pm {pm_sii}
+            update_key FILTER Sii "OSC dual Duo filter extracted"
+            save "{sii_final_path}"
+            """
+
+    siril.run(context["process_dir"], commands, context=context)
+    logger.info(f"Saved final renormalized images to {results_dir}")
+
+
+def osc_dual_duo_post_session():
+    logger.info("Running osc_dual_duo_post_session python script")
+    logger.info("Using context: %s", context)
+
+    # red output channel - from the SiiOiii filter Sii is on the 672nm red channel (mistakenly called Ha by siril)
+    make_stacked("SiiOiii", "Ha", f"results_00001")
+
+    # green output channel - from the HaOiii filter Ha is on the 656nm red channel
+    make_stacked("HaOiii", "Ha", f"results_00001")
+
+    # blue output channel - both filters have Oiii on the 500nm blue channel.  Note the case here is uppercase to match siril output
+    make_stacked("*", "OIII", f"results_00002")
+
+    # There might be an old/state autogenerated .seq file, delete it so it doesn't confuse renormalize
+    results_seq_path = f"{context["process_dir"]}/results_.seq"
+    if os.path.exists(results_seq_path):
+        os.remove(results_seq_path)
+
+    make_renormalize()
+
+
+osc_dual_duo_post_session()