starbash 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

starbash/recipes/master_dark/starbash.toml

@@ -0,0 +1,34 @@
+
+[repo]
+kind = "recipe"
+
+
+[recipe]
+author.name = "FIXMESiril?"
+author.email = "FIXMESiril?"
+
+[recipe.stage.master-dark]
+
+description = "Generate master dark"
+
+tool.name = "siril"
+tool.timeout = 30
+
+input.type = "dark"
+
+# Look for files in input repos, finding them by using the "relative" tag they contain
+input.source = "repo"
+input.required = 2    # siril needs at least 2 frames to stack
+
+# Based on the following definitions in the stage toml file...
+output.dest = "repo"   # write to a particular repo
+output.type = "master" # write output to the special masters repo
+
+script = '''
+    # Convert bias/dark Frames to .fit files
+    link frames -out={process_dir}
+    cd {process_dir}
+
+    # Stack frames
+    stack frames rej 3 3 -nonorm -out={output["base_path"]}
+    '''

starbash/recipes/master_flat/starbash.toml

@@ -8,28 +8,36 @@ author.name = "FIXMESiril?"
 author.email = "FIXMESiril?"
 
 
-[[stage]]
+[recipe.stage.master-flat]
+
+# See master_bias/starbash.toml for more documentation
 
 description = "Generate master flat"
-disabled = true # FIXME, debugging later stuff
+# disabled = false
 
-# For any camera
-auto.for-camera = []
+tool.name = "siril"
+# tool.timeout = 15.0 # allow up to 15 seconds before we timeout and kill tool
 
-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
+# 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 = "flat" # look in all raw repos, 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)
+# Look for files in input repos, finding them by using the "relative" tag they contain
+input.source = "repo"
+input.required = 2    # siril needs at least 2 frames to stack
 
-when = "session-config" # run once per session-config
-context.output = "{process_dir}/flat_s{sessionid}_c{sessionconfig}.fits"
+# We require a master bias frame for this recipe.  By the time our recipe is invoked
+# context.master.bias will have been set to a full path to a master bias frame
+input.masters = ["bias"]
 
-# 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'
+# Based on the following definitions in the stage toml file...
+output.dest = "repo"   # write to a particular repo
+output.type = "master" # write output to the special masters repo
+
+# 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*"
 
 script = '''
     # Create a sequence from the raw flat frames
@@ -37,10 +45,10 @@ script = '''
     cd {process_dir}
 
     # Calibrate the flat frames using master bias
-    calibrate flat -bias={bias}
+    calibrate flat -bias={master["bias"]}
 
-    # Stack the pre-processed (calibrated) flat frames (writes to flat_stacked.fit)
-    stack pp_flat rej 3 3 -norm=mul -out=flat_stacked
+    # Stack the pre-processed (calibrated) flat frames
+    stack pp_flat rej 3 3 -norm=mul -out={output["base_path"]}
     '''
 
 temporaries = ["flat", "pp_flat"]

starbash/recipes/osc_dual_duo/starbash.py

@@ -4,6 +4,7 @@
 import os
 from glob import glob
 from starbash.tool import tools
+from starbash.aliases import normalize_target_name
 
 siril = tools["siril"]
 
@@ -18,11 +19,6 @@ def perhaps_delete_temps(temps: list[str]) -> None:
                 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

starbash/recipes/osc_dual_duo/starbash.toml

@@ -2,21 +2,10 @@
 [repo]
 kind = "recipe"
 
-# all sb.toml files can optionally contain a version section.  if version of the running starbash app is out of bounds a warning message will be printed
-# to the user and the file will be ignored for future processing.
-[recipe.require.version]
-min="0.1.0"
-max="4.5.8"
-
 [recipe]
 author.name = "Kevin Hester"
 author.email = "kevinh@geeksville.com"
 
-[[stage]]
-
-description = "Extract OSC dual duo filter Ha, Oiii and Sii channels"
-disabled = true # FIXME, debugging later stuff
-
 # FIXME-somehow-specify-what-filternames are used to auto detect this recipe can be used?
 # figure out how to support dual duo vs single duo.  Perhaps: the FIRST recipe that matches an auto rule
 # is used for any auto-defected defaults.  If an auto match is found it will be saved in the generated starter
@@ -25,26 +14,39 @@ disabled = true # FIXME, debugging later stuff
 # non OSC people use names like LRGB or SHO
 
 # for dual duo if we see Sii assume they also have HaOiii
-auto.for-filter = ["SiiOiii"]
+auto.require.filter = ["SiiOiii"]
 # for single duo look for this
-# auto.for-filter = ["HaOiii"]
-auto.for-camera = ["OSC"]
+# auto.require.filter = ["HaOiii"]
+auto.require.camera = ["OSC"]
+
+# all sb.toml files can optionally contain a version section.  if version of the running starbash app is out of bounds a warning message will be printed
+# to the user and the file will be ignored for future processing.
+[recipe.require.version]
+min="0.1.0"
+max="4.5.8"
+
+[recipe.stage.light]
+
+description = "Extract OSC dual duo filter Ha, Oiii and Sii channels"
+# disabled = true # FIXME, debugging later stuff
 
-tool = "siril"
-when = "session-light" # run once per session-config
-output = "FIXME"
+tool.name = "siril"
+
+when = "session.light" # run once per session.config
+
+input.masters = ["bias", "flat"]
 
 # FIXME, bias and flat should have been added to context by two previous stages.  But for now hardwire
 # Note: they should not have filename extensions (see strip_extension in the old process.py)
-context.bias = '/workspaces/starbash/images/masters/biases/2025-09-09_stacked.fits'
+# context.bias = '/workspaces/starbash/images/masters/biases/2025-09-09_stacked.fits'
 
-context.sessionid = "2025-09-16" # FIXME, generate this by looping over all sessions (from outside this file)
-context.sessionconfig = "SiiOiii" # FIXME generate this by looping over all session configs
-context.light_base = "light_s{sessionid}_c{sessionconfig}"
+# context.sessionid = "2025-09-16" # FIXME, generate this by looping over all sessions (from outside this file)
+# context.sessionconfig = "SiiOiii" # FIXME generate this by looping over all session configs
+# context.light_base = "light_s{sessionid}_c{sessionconfig}"
 
 # FIXME until auto light finding is in
-input.source = "path"
-input.path = "/workspaces/starbash/images/from_astroboy/M 27/2025-09-16/LIGHT/*.fit*"
+# input.source = "path"
+# input.path = "/workspaces/starbash/images/from_astroboy/M 27/2025-09-16/LIGHT/*.fit*"
 
 script = '''
     # Create a sequence from the raw light frames, seq file goes to process_dir
@@ -63,7 +65,12 @@ script = '''
 
 temporaries = ["FIXME"]
 
-[[stage]]
+[recipe.stage.stack]
+
+disabled = false # not yet ready to test
+
+# FIXME this stage should only be considered if the previous stage in this same array
+# was run.  It must be run inside the same tempdir (so that files from previous stage are available)
 
 # FIXME, eventually we could make it optional to even have a starbash.toml.  If we find an
 # starbash.py we could introspect it for a starbash_config dict.  And look inside that for description
@@ -71,11 +78,17 @@ temporaries = ["FIXME"]
 
 description = "Stack OSC dual duo filter data, with separate Ha, Oiii and Sii channels"
 
-context.target = "M 27" # FIXME
-context.targets = "/workspaces/starbash/images/processed" # FIXME, do something smarter
+# context.target = "M 27" # FIXME
+# context.targets = "/workspaces/starbash/images/processed" # FIXME, do something smarter
+
+tool.name = "python"
+
+when = "final.stack" # run once after all session/session.config processing was done
 
-tool = "python"
-when = "session-stack" # run once after all session/session-config processing was done
+# Based on the following definitions in the stage toml file...
+# FIXME, we should inherit this - most recipes shouldn't have to declare it
+output.dest = "repo" # write to a particular repo
+output.type = "processed" # write output to the special masters repo
 
 # if not specified starbash.py used
 # script-file = "script.py"

starbash/recipes/osc_single_duo/starbash.toml

@@ -23,8 +23,8 @@ disabled = true # FIXME, we don't yet have auto selection based on filter types
 auto.for-filter = ["HaOiii"]
 auto.for-camera = ["OSC"]
 
-tool = "siril"
-when = "session-light" # run once per session-config
+tool.name = "siril"
+when = "session.light" # run once per session.config
 output = "FIXME"
 
 script = '''
@@ -45,8 +45,8 @@ temporaries = ["FIXME"]
 
 disabled = true # FIXME, we don't yet have auto selection based on filter types
 
-tool = "python"
-when = "session-stack" # run once after all session/session-config processing was done
+tool.name = "python"
+when = "session.stack" # run once after all session/session.config processing was done
 
 script-file = "script.py"
 

starbash/recipes/starbash.toml

@@ -5,6 +5,8 @@ kind = "repo"
 [[repo-ref]]
 dir = "master_bias"
 [[repo-ref]]
+dir = "master_dark"
+[[repo-ref]]
 dir = "master_flat"
 
 # Note: For automated recipe finding, it is important to list more demanding recipes first.  For instance:
@@ -26,14 +28,34 @@ dir = "osc_single_duo"
 #name = "setup-masters" # for flat processing, master generation etc
 #priority = 5
 
-[[stages]]
-name = "session-config" # for flat processing, master generation etc
+#
+# master specific stages
+#
+[[master-stages]]
+name = "master-bias" # generate master bias frames
+priority = 10
+input = "bias" # only used for frames of this type
+
+[[master-stages]]
+name = "master-dark" # generate master dark frames
 priority = 10
+input = "dark"
+
+[[master-stages]]
+name = "master-flat" # generate master flat frames
+priority = 20
+input = "flat"
+
+#
+# session specific processing stages, not currently used, for now I just do this list from code
+#
 
 [[stages]]
-name = "session-light" # generate light frames from lights and with reference to flats/bias
+name = "light" # generate light frames from lights and with reference to flats/bias
 priority = 20
+input = "light" # only used for frames of this type
 
 [[stages]]
-name = "session-stack" # stack frames
+name = "stack" # stack frames
 priority = 30
+input = "light" # only used for frames of this type

starbash/selection.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from typing import Any, Optional, TYPE_CHECKING
 from repo import Repo
+from starbash.aliases import normalize_target_name
 
 
 def where_tuple(conditions: dict[str, Any] | None) -> tuple[str, list[Any]]:
@@ -256,7 +257,11 @@ class Selection:
         if self.targets:
             # For now, just use the first target
             # TODO: Support multiple targets in queries
-            conditions["OBJECT"] = self.targets[0] if len(self.targets) == 1 else None
+            conditions["OBJECT"] = (
+                normalize_target_name(self.targets[0])
+                if len(self.targets) == 1
+                else None
+            )
 
         if self.filters:
             # For now, just use the first filter

starbash/templates/repo/processed.toml

@@ -0,0 +1,10 @@
+# This is a processed repository for (Starbash)[{PROJECT_URL}].
+#
+# This file marks the root directory of a set of generated/processed starbash output files.
+#
+# You generally don't need to edit this file directly - it was auto generated when you ran
+# "sb repo add --processed {REPO_PATH}".
+#
+
+[repo]
+kind = "processed"

starbash/tool.py

@@ -4,9 +4,9 @@ import textwrap
 import tempfile
 import subprocess
 import re
-
+import threading
+import queue
 import logging
-
 import RestrictedPython
 
 logger = logging.getLogger(__name__)
@@ -161,83 +161,133 @@ def strip_comments(text: str) -> str:
     return "\n".join(lines)
 
 
-def tool_run(cmd: str, cwd: str, commands: str | None = None) -> None:
-    """Executes an external tool with an optional script of commands in a given working directory."""
-
-    logger.debug(f"Running {cmd} in {cwd}: stdin={commands}")
-    result = subprocess.run(
-        cmd, input=commands, shell=True, capture_output=True, text=True, cwd=cwd
-    )
-
-    if result.stderr:
-        logger.warning(f"Tool error message:\n{result.stderr.strip()}")
+def tool_run(
+    cmd: str, cwd: str, commands: str | None = None, timeout: float | None = None
+) -> None:
+    """Executes an external tool with an optional script of commands in a given working directory.
 
-    if result.returncode != 0:
-        # If we got an error, print the entire tool stdout as a warning
-        logger.warning(f"Tool output:\n{result.stdout.strip()}")
-        raise RuntimeError(f"Tool failed with exit code {result.returncode}")
-    else:
-        logger.debug("Tool command successful.")
+    Streams stdout and stderr in real-time to the logger, allowing you to see subprocess output
+    as it happens rather than waiting for completion.
+    """
 
-    if result.stdout:
-        logger.debug(f"Tool output:\n{result.stdout.strip()}")
+    logger.debug(f"Running {cmd} in {cwd}: stdin={commands}")
 
+    # Start the process with pipes for streaming
+    process = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE if commands else None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=True,
+        text=True,
+        cwd=cwd,
+    )
 
-def executable_path(commands: list[str], name: str) -> str:
-    """Find the correct executable path to run for the given tool"""
-    for cmd in commands:
-        if shutil.which(cmd):
-            return cmd
-    raise FileNotFoundError(f"{name} not found, you probably need to install it.")
+    # Send commands to stdin if provided
+    if commands and process.stdin:
+        try:
+            process.stdin.write(commands)
+            process.stdin.close()
+        except BrokenPipeError:
+            # Process may have terminated early
+            pass
 
+    # Stream output line by line in real-time
+    # Use threading for cross-platform compatibility (select doesn't work on Windows with pipes)
 
-def siril_run(temp_dir: str, commands: str, input_files: list[str] = []) -> None:
-    """Executes Siril with a script of commands in a given working directory."""
+    assert process.stdout
+    assert process.stderr
 
-    # siril_path = "/home/kevinh/packages/Siril-1.4.0~beta3-x86_64.AppImage"
-    # Possible siril commands, with preferred option first
-    siril_commands = ["org.siril.Siril", "siril-cli", "siril"]
-    siril_path = executable_path(siril_commands, "Siril")
-    if siril_path == "org.siril.Siril":
-        # The executable is inside a flatpak, so run the lighter/faster/no-gui required exe
-        # from inside the flatpak
-        siril_path = "flatpak run --command=siril-cli org.siril.Siril"
+    output_queue: queue.Queue = queue.Queue()
 
-    # Create symbolic links for all input files in the temp directory
-    for f in input_files:
-        os.symlink(
-            os.path.abspath(str(f)), os.path.join(temp_dir, os.path.basename(str(f)))
-        )
+    def read_stream(stream, log_func, stream_name):
+        """Read from stream and put lines in queue."""
+        try:
+            for line in stream:
+                line = line.rstrip("\n")
+                output_queue.put((log_func, stream_name, line))
+        finally:
+            output_queue.put((None, stream_name, None))  # Signal EOF
 
-    # We dedent here because the commands are often indented multiline strings
-    script_content = textwrap.dedent(
-        f"""
-        requires 1.4.0-beta3
-        {textwrap.dedent(strip_comments(commands))}
-        """
+    # Start threads to read stdout and stderr
+    stdout_thread = threading.Thread(
+        target=read_stream,
+        args=(process.stdout, logger.debug, "tool-stdout"),
+        daemon=True,
     )
-
-    logger.info(
-        f"Running Siril in {temp_dir}, ({len(input_files)} input files) cmds:\n{script_content}"
+    stderr_thread = threading.Thread(
+        target=read_stream,
+        args=(process.stderr, logger.warning, "tool-stderr"),
+        daemon=True,
     )
 
-    # The `-s -` arguments tell Siril to run in script mode and read commands from stdin.
-    # It seems like the -d command may also be required when siril is in a flatpak
-    cmd = f"{siril_path} -d {temp_dir} -s -"
+    stdout_thread.start()
+    stderr_thread.start()
 
-    tool_run(cmd, temp_dir, script_content)
+    # Track which streams have finished
+    streams_finished = 0
 
+    try:
+        # Process output from queue until both streams are done
+        while streams_finished < 2:
+            try:
+                # Use timeout to periodically check if process has terminated
+                log_func, stream_name, line = output_queue.get(timeout=0.1)
+
+                if log_func is None:
+                    # EOF signal
+                    streams_finished += 1
+                else:
+                    # Log the line
+                    log_func(f"[{stream_name}] {line}")
+
+            except queue.Empty:
+                # No output available, check if process terminated
+                if process.poll() is not None:
+                    # Process finished, wait a bit more for remaining output
+                    break
+
+        # Wait for threads to finish (they should be done or very close)
+        stdout_thread.join(timeout=1.0)
+        stderr_thread.join(timeout=1.0)
+
+        # Drain any remaining items in queue
+        while not output_queue.empty():
+            try:
+                log_func, stream_name, line = output_queue.get_nowait()
+                if log_func is not None:
+                    log_func(f"[{stream_name}] {line}")
+            except queue.Empty:
+                break
 
-def graxpert_run(cwd: str, arguments: str) -> None:
-    """Executes Graxpert with the specified command line arguments"""
-
-    graxpert_commands = ["graxpert"]
-    graxpert_path = executable_path(graxpert_commands, "Graxpert")
+        # Wait for process to complete with timeout
+        try:
+            process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+            raise RuntimeError(f"Tool timed out after {timeout} seconds")
+
+        returncode = process.returncode
+
+        if returncode != 0:
+            raise RuntimeError(f"Tool failed with exit code {returncode}")
+        else:
+            logger.debug("Tool command successful.")
+    finally:
+        # Ensure streams are properly closed
+        if process.stdout:
+            process.stdout.close()
+        if process.stderr:
+            process.stderr.close()
 
-    # Arguments look similar to: graxpert -cmd background-extraction -output /tmp/testout tests/test_images/real_crummy.fits
-    cmd = f"{graxpert_path} {arguments}"
 
-    tool_run(cmd, cwd)
+def executable_path(commands: list[str], name: str) -> str:
+    """Find the correct executable path to run for the given tool"""
+    for cmd in commands:
+        if shutil.which(cmd):
+            return cmd
+    raise FileNotFoundError(f"{name} not found, you probably need to install it.")
 
 
 class Tool:
@@ -248,6 +298,12 @@ class Tool:
 
         # default script file name
         self.default_script_file = None
+        self.set_defaults()
+
+    def set_defaults(self):
+        # default timeout in seconds, if you need to run a tool longer than this, you should change
+        # it before calling run()
+        self.timeout = 10.0
 
     def run_in_temp_dir(self, commands: str, context: dict = {}) -> None:
         """Run commands inside this tool (with cwd pointing to a temp directory)"""
@@ -275,6 +331,7 @@ class SirilTool(Tool):
         super().__init__("siril")
 
     def run(self, cwd: str, commands: str, context: dict = {}) -> None:
+        """Executes Siril with a script of commands in a given working directory."""
 
         # Iteratively expand the command string to handle nested placeholders.
         # The loop continues until the string no longer changes.
@@ -282,7 +339,42 @@ class SirilTool(Tool):
 
         input_files = context.get("input_files", [])
 
-        siril_run(cwd, expanded, input_files)
+        temp_dir = cwd
+
+        # siril_path = "/home/kevinh/packages/Siril-1.4.0~beta3-x86_64.AppImage"
+        # Possible siril commands, with preferred option first
+        siril_commands = ["org.siril.Siril", "siril-cli", "siril"]
+        siril_path = executable_path(siril_commands, "Siril")
+        if siril_path == "org.siril.Siril":
+            # The executable is inside a flatpak, so run the lighter/faster/no-gui required exe
+            # from inside the flatpak
+            siril_path = "flatpak run --command=siril-cli org.siril.Siril"
+
+        # Create symbolic links for all input files in the temp directory
+        for f in input_files:
+            os.symlink(
+                os.path.abspath(str(f)),
+                os.path.join(temp_dir, os.path.basename(str(f))),
+            )
+
+        # We dedent here because the commands are often indented multiline strings
+        script_content = textwrap.dedent(
+            f"""
+            requires 1.4.0-beta3
+            {textwrap.dedent(strip_comments(expanded))}
+            """
+        )
+
+        logger.debug(
+            f"Running Siril in {temp_dir}, ({len(input_files)} input files) cmds:\n{script_content}"
+        )
+        logger.info(f"Running Siril ({len(input_files)} input files)")
+
+        # The `-s -` arguments tell Siril to run in script mode and read commands from stdin.
+        # It seems like the -d command may also be required when siril is in a flatpak
+        cmd = f"{siril_path} -d {temp_dir} -s -"
+
+        tool_run(cmd, temp_dir, script_content, timeout=self.timeout)
 
 
 class GraxpertTool(Tool):
@@ -292,7 +384,12 @@ class GraxpertTool(Tool):
         super().__init__("graxpert")
 
     def run(self, cwd: str, commands: str, context: dict = {}) -> None:
-        graxpert_run(cwd, commands)
+        """Executes Graxpert with the specified command line arguments"""
+
+        # Arguments look similar to: graxpert -cmd background-extraction -output /tmp/testout tests/test_images/real_crummy.fits
+        cmd = f"graxpert {commands}"
+
+        tool_run(cmd, cwd, timeout=self.timeout)
 
 
 class PythonTool(Tool):

{starbash-0.1.9.dist-info → starbash-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: starbash
-Version: 0.1.9
+Version: 0.1.11
 Summary: A tool for automating/standardizing/sharing astrophotography workflows.
 License-File: LICENSE
 Author: Kevin Hester
@@ -33,6 +33,7 @@ A tool for automating/standardizing/sharing astrophotography workflows.
 * Automatic - with sensible defaults, that you can change as needed.
 * Easy - provides a 'seestar like' starting-point for autoprocessing all your sessions (by default).
 * Fast - even with large image repositories.  Automatic master bias and flat generation and reasonable defaults
+* Multi-session - by default.  So your workflows can stack from multiple nights (and still use the correct flats etc...)
 * Sharable - you can share/use recipes for image preprocessing flows.
 
 (This project is currently 'alpha' and missing recipes for some workflows, but adding new recipes is easy and we're happy to help.  Please file a github issue if your images are not auto-processed and we'll work out a fix.)
@@ -89,7 +90,7 @@ FIXME - add getting started instructions (possibly with a screenshare video)
 
 ### Repository Management
 - `sb repo list [--verbose]` - List installed repos (use `-v` for details)
-- `sb repo add [--master] <filepath|URL>` - Add a repository, optionally specifying the type
+- `sb repo add [--master] [filepath|URL]` - Add a repository, optionally specifying the type
 - `sb repo remove <REPOURL>` - Remove the indicated repo from the repo list
 - `sb repo reindex [--force] <REPOURL>` - Reindex the specified repo (or all repos if none specified)
 
@@ -113,6 +114,7 @@ FIXME - add getting started instructions (possibly with a screenshare video)
 - `sb info target` - List targets (filtered based on the current selection)
 - `sb info telescope` - List instruments (filtered based on the current selection)
 - `sb info filter` - List all filters found in current selection
+- `sb info master [KIND]` - List all precalculated master images (darks, biases, flats). Optional KIND argument to filter by image type (e.g., BIAS, DARK, FLAT)
 
 ## Not yet supported commands
 
@@ -142,4 +144,4 @@ Project members can access crash reports [here](https://geeksville.sentry.io/ins
 ## License
 
 Copyright 2025 Kevin Hester, kevinh@geeksville.com.
-Licensed under the (GPL v3)[LICENSE]
+Licensed under the [GPL v3](LICENSE)