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

starbash/database.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
+import json
 import sqlite3
-from pathlib import Path
-from typing import Any, Optional, NamedTuple
+from dataclasses import dataclass
 from datetime import datetime, timedelta
-import json
-from typing import TypeAlias
+from pathlib import Path
+from typing import Any
 
-from .paths import get_user_data_dir
 from .aliases import normalize_target_name
+from .paths import get_user_data_dir
 
-SessionRow: TypeAlias = dict[str, Any]
-ImageRow: TypeAlias = dict[str, Any]
+type SessionRow = dict[str, Any]
+type ImageRow = dict[str, Any]
 
 
-class SearchCondition(NamedTuple):
+@dataclass(frozen=True)
+class SearchCondition:
     """A search condition for database queries.
 
     Args:
@@ -83,7 +84,9 @@ class Database:
     IMAGETYP_KEY = "IMAGETYP"
     OBJECT_KEY = "OBJECT"
     TELESCOP_KEY = "TELESCOP"
-    EXPTIME_KEY = "EXPTIME"
+    EXPTIME_KEY = "EXPTIME"  # in all image files
+    TOTALEXP_KEY = "TOTALEXP"  # in stacked ASI files
+
     ID_KEY = "id"  # for finding any row by its ID
     REPO_URL_KEY = "repo_url"
 
@@ -93,7 +96,7 @@ class Database:
 
     def __init__(
         self,
-        base_dir: Optional[Path] = None,
+        base_dir: Path | None = None,
     ) -> None:
         # Resolve base data directory (allow override for tests)
         if base_dir is None:
@@ -187,7 +190,7 @@ class Database:
                 filter TEXT COLLATE NOCASE,
                 imagetyp TEXT COLLATE NOCASE NOT NULL,
                 object TEXT,
-                telescop TEXT NOT NULL,
+                telescop TEXT COLLATENOCASE NOT NULL,
                 num_images INTEGER NOT NULL,
                 exptime_total REAL NOT NULL,
                 exptime REAL NOT NULL,
@@ -426,26 +429,41 @@ class Database:
 
         return results
 
-    def search_session(
-        self, where_tuple: tuple[str, list[Any]] = ("", [])
-    ) -> list[SessionRow]:
+    def search_session(self, conditions: list[SearchCondition] = []) -> list[SessionRow]:
         """Search for sessions matching the given conditions.
 
         Args:
-            where_tuple
+            conditions: List of SearchCondition tuples for filtering sessions.
+                       Column names should be from the sessions table. If no table prefix
+                       is given (e.g., "OBJECT"), it will be prefixed with "s." automatically.
 
         Returns:
-            List of matching session records with metadata from the reference image
+            List of matching session records with metadata from the reference image and repo_url
         """
-        # Build WHERE clause dynamically based on conditions
-        where_clause, params = where_tuple
+        # Build WHERE clause from SearchCondition list
+        where_clauses = []
+        params = []
+
+        for condition in conditions:
+            # Add table prefix 's.' if not already present to avoid ambiguous column names
+            column_name = condition.column_name
+            if "." not in column_name:
+                # Session table columns that might be ambiguous with images table
+                column_name = f"s.{column_name.lower()}"
+            where_clauses.append(f"{column_name} {condition.comparison_op} ?")
+            params.append(condition.value)
+
+        # Build the query with JOIN to images and repos tables to get reference image metadata and repo_url
+        where_clause = ""
+        if where_clauses:
+            where_clause = " WHERE " + " AND ".join(where_clauses)
 
-        # Build the query with JOIN to images table to get reference image metadata
         query = f"""
             SELECT s.id, s.start, s.end, s.filter, s.imagetyp, s.object, s.telescop,
-                   s.num_images, s.exptime_total, s.exptime, s.image_doc_id, i.metadata
+                   s.num_images, s.exptime_total, s.exptime, s.image_doc_id, i.metadata, r.url as repo_url
             FROM {self.SESSIONS_TABLE} s
             LEFT JOIN {self.IMAGES_TABLE} i ON s.image_doc_id = i.id
+            LEFT JOIN {self.REPOS_TABLE} r ON i.repo_id = r.id
             {where_clause}
         """
 
@@ -684,9 +702,7 @@ class Database:
 
         return dict(row)
 
-    def upsert_session(
-        self, new: SessionRow, existing: SessionRow | None = None
-    ) -> None:
+    def upsert_session(self, new: SessionRow, existing: SessionRow | None = None) -> None:
         """Insert or update a session record."""
         cursor = self._db.cursor()
 
@@ -734,9 +750,7 @@ class Database:
                     new[get_column_name(Database.END_KEY)],
                     new.get(get_column_name(Database.FILTER_KEY)),
                     new[get_column_name(Database.IMAGETYP_KEY)],
-                    normalize_target_name(
-                        new.get(get_column_name(Database.OBJECT_KEY))
-                    ),
+                    normalize_target_name(new.get(get_column_name(Database.OBJECT_KEY))),
                     new.get(get_column_name(Database.TELESCOP_KEY)),
                     new[get_column_name(Database.NUM_IMAGES_KEY)],
                     new[get_column_name(Database.EXPTIME_TOTAL_KEY)],
@@ -752,7 +766,7 @@ class Database:
         self._db.close()
 
     # Context manager support
-    def __enter__(self) -> "Database":
+    def __enter__(self) -> Database:
         return self
 
     def __exit__(self, exc_type, exc, tb) -> None:

starbash/defaults/starbash.toml

@@ -24,6 +24,7 @@ HaOiii = ["HaOiii", "HaO3"]
 None = ["None"]
 
 camera_osc = ["OSC", "ZWO ASI2600MC Duo"]
+camera_seestar = ["Seestar", "Seestar S50", "Seestar S30", "Seestar S30 Pro"]
 
 # Passes SII 672.4nm and H-Beta 486.1nm lines
 # Capturing of the two main emission wavebands in the deep red and blue at the same time

starbash/exception.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+
+class UserHandledError(ValueError):
+    """An exception that terminates processing of the current file, but we want to help the user fix the problem."""
+
+    def ask_user_handled(self) -> bool:
+        """Prompt the user with a friendly message about the error.
+        Returns:
+            True if the error was handled, False otherwise.
+        """
+        from starbash import console  # Lazy import to avoid circular dependency
+
+        console.print(f"Error: {self}")
+        return False
+
+    def __rich__(self) -> Any:
+        return self.__str__()  # At least this is something readable...
+
+
+__all__ = ["UserHandledError"]

starbash/main.py

@@ -1,13 +1,24 @@
 import logging
+import warnings
+from typing import Annotated
+
 import typer
-from typing_extensions import Annotated
 
-import starbash.url as url
 import starbash
+import starbash.url as url
 
-from .app import Starbash, get_user_config_path, setup_logging
-from .commands import info, process, repo, select, user
 from . import console
+from .analytics import is_development_environment
+from .app import Starbash
+from .commands import info, process, repo, select, user
+from .paths import get_user_config_path
+
+# Suppress deprecation warnings in production mode to provide a cleaner user experience.
+# In development mode (VS Code, devcontainer, or SENTRY_ENVIRONMENT=development),
+# all warnings are shown to help developers identify potential issues.
+# See: is_development_environment() in analytics.py for detection logic.
+if not is_development_environment():
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 app = typer.Typer(
     rich_markup_mode="rich",
@@ -17,9 +28,7 @@ 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(select.app, name="select", help="Manage session and target selection.")
 app.add_typer(info.app, name="info", help="Display system and data information.")
-app.add_typer(
-    process.app, name="process", help="Process images using automated workflows."
-)
+app.add_typer(process.app, name="process", help="Process images using automated workflows.")
 
 
 @app.callback(invoke_without_command=True)
@@ -32,11 +41,24 @@ def main_callback(
             help="Enable debug logging output.",
         ),
     ] = False,
+    force: bool = typer.Option(
+        default=False,
+        help="Force reindexing/output file regeneration - even if unchanged.",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        help="When providing responses, include all entries.  Normally long responses are truncated.",
+    ),
 ):
     """Main callback for the Starbash application."""
     # Set the log level based on --debug flag
     if debug:
         starbash.log_filter_level = logging.DEBUG
+    if force:
+        starbash.force_regen = True
+    if verbose:
+        starbash.verbose_output = True
 
     if ctx.invoked_subcommand is None:
         if not get_user_config_path().exists():

starbash/paths.py

@@ -1,5 +1,6 @@
 import os
 from pathlib import Path
+
 from platformdirs import PlatformDirs
 
 app_name = "starbash"
@@ -7,35 +8,45 @@ app_author = "geeksville"
 dirs = PlatformDirs(app_name, app_author)
 config_dir = Path(dirs.user_config_dir)
 data_dir = Path(dirs.user_data_dir)
+cache_dir = Path(dirs.user_cache_dir)
 documents_dir = Path(dirs.user_documents_dir) / "starbash"
 
 # These can be overridden for testing
 _override_config_dir: Path | None = None
 _override_data_dir: Path | None = None
+_override_cache_dir: Path | None = None
 _override_documents_dir: Path | None = None
 
 
 def set_test_directories(
     config_dir_override: Path | None = None,
     data_dir_override: Path | None = None,
+    cache_dir_override: Path | None = None,
     documents_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_documents_dir
+    global _override_config_dir, _override_data_dir, _override_cache_dir, _override_documents_dir
     _override_config_dir = config_dir_override
     _override_data_dir = data_dir_override
+    _override_cache_dir = cache_dir_override
     _override_documents_dir = documents_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
-    )
+    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_config_path() -> Path:
+    """Returns the path to the user config file (starbash.toml)."""
+    from repo import repo_suffix  # Lazy import to avoid circular dependency
+
+    config_dir = get_user_config_dir()
+    return config_dir / repo_suffix
+
+
 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
@@ -43,12 +54,15 @@ def get_user_data_dir() -> Path:
     return dir_to_use
 
 
+def get_user_cache_dir() -> Path:
+    """Get the user cache directory. Returns test override if set, otherwise the real user directory."""
+    dir_to_use = _override_cache_dir if _override_cache_dir is not None else cache_dir
+    os.makedirs(dir_to_use, exist_ok=True)
+    return dir_to_use
+
+
 def get_user_documents_dir() -> Path:
     """Get the user documents directory. Returns test override if set, otherwise the real user directory."""
-    dir_to_use = (
-        _override_documents_dir
-        if _override_documents_dir is not None
-        else documents_dir
-    )
+    dir_to_use = _override_documents_dir if _override_documents_dir is not None else documents_dir
     os.makedirs(dir_to_use, exist_ok=True)
     return dir_to_use