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

starbash/main.py

@@ -1,26 +1,155 @@
 import logging
+from datetime import datetime
+from tomlkit import table
 import typer
+from rich.table import Table
 
-from .app import AstroGlue
-from .commands import repo
+from starbash.database import Database
+import starbash.url as url
 
-app = typer.Typer()
+from .app import Starbash
+from .commands import repo, user, selection
+from . import console
+
+app = typer.Typer(
+    rich_markup_mode="rich",
+    help=f"Starbash - Astrophotography workflows simplified.\n\nFor full instructions and support [link={url.project}]click here[/link].",
+)
+app.add_typer(user.app, name="user", help="Manage user settings.")
 app.add_typer(repo.app, name="repo", help="Manage Starbash repositories.")
+app.add_typer(
+    selection.app, name="selection", help="Manage session and target selection."
+)
+
 
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context):
+    """Main callback for the Starbash application."""
+    if ctx.invoked_subcommand is None:
+        # No command provided, show help
+        console.print(ctx.get_help())
+        raise typer.Exit()
 
-@app.command(hidden=True)
-def default_cmd():
-    """Default entry point for the starbash application."""
 
-    with AstroGlue() as ag:
-        pass
+def format_duration(seconds: int):
+    """Format seconds as a human-readable duration string."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 120:
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s" if secs else f"{minutes}m"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return f"{hours}h {minutes}m" if minutes else f"{hours}h"
 
 
-@app.callback(invoke_without_command=True)
-def _default(ctx: typer.Context):
-    # If the user didn’t specify a subcommand, run the default
-    if ctx.invoked_subcommand is None:
-        return default_cmd()
+@app.command()
+def session():
+    """List sessions (filtered based on the current selection)"""
+
+    with Starbash("session") as sb:
+        sessions = sb.search_session()
+        if sessions and isinstance(sessions, list):
+            len_all = sb.db.len_session()
+            table = Table(title=f"Sessions ({len(sessions)} selected out of {len_all})")
+
+            table.add_column("Date", style="cyan", no_wrap=True)
+            table.add_column("# images", style="cyan", no_wrap=True)
+            table.add_column("Time", style="cyan", no_wrap=True)
+            table.add_column("Type/Filter", style="cyan", no_wrap=True)
+            table.add_column("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__":

starbash/paths.py

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

starbash/repo/manager.py

@@ -5,20 +5,24 @@ Manages the repository of processing recipes and configurations.
 from __future__ import annotations
 import logging
 from pathlib import Path
+from importlib import resources
 
 import tomlkit
+from tomlkit.toml_file import TOMLFile
 from tomlkit.items import AoT
 from multidict import MultiDict
 
 
 repo_suffix = "starbash.toml"
 
+REPO_REF = "repo-ref"
+
 
 class Repo:
     """
     Represents a single starbash repository."""
 
-    def __init__(self, manager: RepoManager, url: str, config: str | None = None):
+    def __init__(self, manager: RepoManager, url: str):
         """
         Initializes a Repo instance.
 
@@ -27,15 +31,14 @@ class Repo:
         """
         self.manager = manager
         self.url = url
-        self.config = tomlkit.parse(config) if config else self._load_config()
-        self.manager.add_all_repos(self.config, self.get_path())
+        self.config = self._load_config()
 
     def __str__(self) -> str:
         """Return a concise one-line description of this repo.
 
         Example: "Repo(kind=recipe, local=True, url=file:///path/to/repo)"
         """
-        return f"Repo(kind={self.kind}, local={self.is_local}, url={self.url})"
+        return f"Repo(kind={self.kind}, url={self.url})"
 
     __repr__ = __str__
 
@@ -49,8 +52,37 @@ class Repo:
         """
         return str(self.get("repo.kind", "unknown"))
 
-    @property
-    def is_local(self) -> bool:
+    def add_repo_ref(self, dir: str) -> None:
+        aot = self.config.get(REPO_REF, None)
+        if aot is None:
+            aot = tomlkit.aot()
+        else:
+            self.config.remove(
+                REPO_REF
+            )  # We want to completely replace it at the end of the file
+
+        ref = {"dir": dir}
+        aot.append(ref)
+        self.config[REPO_REF] = aot
+        self.add_from_ref(ref)
+
+    def write_config(self) -> None:
+        """
+        Writes the current (possibly modified) configuration back to the repository's config file.
+
+        Raises:
+            ValueError: If the repository is not a local file repository.
+        """
+        base_path = self.get_path()
+        if base_path is None:
+            raise ValueError("Cannot resolve path for non-local repository")
+
+        config_path = base_path / repo_suffix
+        # FIXME, be more careful to write the file atomically (by writing to a temp file and renaming)
+        TOMLFile(config_path).write(self.config)
+        logging.debug(f"Wrote config to {config_path}")
+
+    def is_scheme(self, scheme: str = "file") -> bool:
         """
         Read-only attribute indicating whether the repository URL points to a
         local file system path (file:// scheme).
@@ -58,7 +90,7 @@ class Repo:
         Returns:
             bool: True if the URL is a local file path, False otherwise.
         """
-        return self.url.startswith("file://")
+        return self.url.startswith(f"{scheme}://")
 
     def get_path(self) -> Path | None:
         """
@@ -70,12 +102,39 @@ class Repo:
         Returns:
             A Path object if the URL is a local file, otherwise None.
         """
-        if self.is_local:
+        if self.is_scheme("file"):
             return Path(self.url[len("file://") :])
 
         return None
 
-    def read(self, filepath: str) -> str:
+    def add_from_ref(self, ref: dict) -> None:
+        """
+        Adds a repository based on a repo-ref dictionary.
+        """
+        if "url" in ref:
+            url = ref["url"]
+        elif "dir" in ref:
+            path = Path(ref["dir"])
+            base_path = self.get_path()
+            if base_path and not path.is_absolute():
+                # Resolve relative to the current TOML file's directory
+                path = (base_path / path).resolve()
+            else:
+                # Expand ~ and resolve from CWD
+                path = path.expanduser().resolve()
+            url = f"file://{path}"
+        else:
+            raise ValueError(f"Invalid repo reference: {ref}")
+        self.manager.add_repo(url)
+
+    def add_by_repo_refs(self) -> None:
+        """Add all repos mentioned by repo-refs in this repo's config."""
+        repo_refs = self.config.get(REPO_REF, [])
+
+        for ref in repo_refs:
+            self.add_from_ref(ref)
+
+    def _read_file(self, filepath: str) -> str:
         """
         Read a filepath relative to the base of this repo. Return the contents in a string.
 
@@ -96,7 +155,31 @@ class Repo:
 
         return target_path.read_text()
 
-    def _load_config(self) -> dict:
+    def _read_resource(self, filepath: str) -> str:
+        """
+        Read a resource from the installed starbash package using a pkg:// URL.
+
+        Assumptions (simplified per project constraints):
+        - All pkg URLs point somewhere inside the already-imported 'starbash' package.
+        - The URL is treated as a path relative to the starbash package root.
+
+        Examples:
+            url: pkg://defaults   + filepath: "starbash.toml"
+              -> reads starbash/defaults/starbash.toml
+
+        Args:
+            filepath: Path within the base resource directory for this repo.
+
+        Returns:
+            The content of the resource as a string (UTF-8).
+        """
+        # Path portion after pkg://, interpreted relative to the 'starbash' package
+        subpath = self.url[len("pkg://") :].strip("/")
+
+        res = resources.files("starbash").joinpath(subpath).joinpath(filepath)
+        return res.read_text()
+
+    def _load_config(self) -> tomlkit.TOMLDocument:
         """
         Loads the repository's configuration file (e.g., repo.sb.toml).
 
@@ -106,12 +189,19 @@ class Repo:
             A dictionary containing the parsed configuration.
         """
         try:
-            config_content = self.read(repo_suffix)
+            if self.is_scheme("file"):
+                config_content = self._read_file(repo_suffix)
+            elif self.is_scheme("pkg"):
+                config_content = self._read_resource(repo_suffix)
+            else:
+                raise ValueError(f"Unsupported URL scheme for repo: {self.url}")
             logging.debug(f"Loading repo config from {repo_suffix}")
             return tomlkit.parse(config_content)
         except FileNotFoundError:
-            logging.warning(f"No {repo_suffix} found")
-            return {}
+            logging.debug(
+                f"No {repo_suffix} found"
+            )  # we currently make it optional to have the config file at root
+            return tomlkit.TOMLDocument()  # empty placeholder
 
     def get(self, key: str, default=None):
         """
@@ -142,42 +232,36 @@ class RepoManager:
     files (like appdefaults.sb.toml).
     """
 
-    def __init__(self, app_defaults: str):
+    def __init__(self):
         """
         Initializes the RepoManager by loading the application default repos.
         """
         self.repos = []
 
         # We expose the app default preferences as a special root repo with a private URL
-        root_repo = Repo(self, "pkg://starbash-defaults", config=app_defaults)
-        self.repos.append(root_repo)
+        # root_repo = Repo(self, "pkg://starbash-defaults", config=app_defaults)
+        # self.repos.append(root_repo)
 
         # Most users will just want to read from merged
-        self.merged = self._union()
-
-    def add_all_repos(self, toml: dict, base_path: Path | None = None) -> None:
-        # From appdefaults.sb.toml, repo.ref is a list of tables
-        repo_refs = toml.get("repo", {}).get("ref", [])
+        self.merged = MultiDict()
 
-        for ref in repo_refs:
-            if "url" in ref:
-                url = ref["url"]
-            elif "dir" in ref:
-                path = Path(ref["dir"])
-                if base_path and not path.is_absolute():
-                    # Resolve relative to the current TOML file's directory
-                    path = (base_path / path).resolve()
-                else:
-                    # Expand ~ and resolve from CWD
-                    path = path.expanduser().resolve()
-                url = f"file://{path}"
-            else:
-                raise ValueError(f"Invalid repo reference: {ref}")
-            self.add_repo(url)
+    @property
+    def regular_repos(self) -> list[Repo]:
+        "We exclude certain repo types (preferences, recipe) from the list of repos users care about."
+        return [r for r in self.repos if r.kind not in ("preferences", "recipe")]
 
-    def add_repo(self, url: str) -> None:
+    def add_repo(self, url: str) -> Repo:
         logging.debug(f"Adding repo: {url}")
-        self.repos.append(Repo(self, url))
+        r = Repo(self, url)
+        self.repos.append(r)
+
+        # FIXME, generate the merged dict lazily
+        self._add_merged(r)
+
+        # if this new repo has sub-repos, add them too
+        r.add_by_repo_refs()
+
+        return r
 
     def get(self, key: str, default=None):
         """
@@ -214,32 +298,18 @@ class RepoManager:
             # For a debug dump, a simple string representation is usually sufficient.
             logging.info(f"  %s: %s", key, value)
 
-    def _union(self) -> MultiDict:
-        """
-        Merges the top-level keys from all repository configurations into a MultiDict.
-
-        This method iterates through all loaded repositories in their original order
-        and combines their top-level configuration keys. If a key exists in multiple
-        repositories, all of its values will be present in the returned MultiDict.
-
-        Returns:
-            A MultiDict containing the union of all top-level keys.
-        """
-        merged_dict = MultiDict()
-        for repo in self.repos:
-            for key, value in repo.config.items():
-                # if the toml object is an AoT type, monkey patch each element in the array instead
-                if isinstance(value, AoT):
-                    for v in value:
-                        setattr(v, "source", repo)
+    def _add_merged(self, repo: Repo) -> None:
+        for key, value in repo.config.items():
+            # if the toml object is an AoT type, monkey patch each element in the array instead
+            if isinstance(value, AoT):
+                for v in value:
+                    setattr(v, "source", repo)
                 else:
                     # We monkey patch source into any object that came from a repo, so that users can
                     # find the source repo (for attribution, URL relative resolution, whatever...)
                     setattr(value, "source", repo)
 
-                merged_dict.add(key, value)
-
-        return merged_dict
+            self.merged.add(key, value)
 
     def __str__(self):
         lines = [f"RepoManager with {len(self.repos)} repositories:"]