Honor tx_color picker when creating site after simulation

Previously always used the palette color, ignoring the admin's
manual color selection. Now uses tx_color when set (non-empty),
falling back to the rotating palette when auto-color is enabled.

Fixes meshtastic#53.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JamesonRGrieve

TODOS.SHIP.md

@@ -55,7 +55,7 @@
 
 - [x] 30. `Literal[tuple(AVAILABLE_COLORMAPS)]` evaluated at import time (`CoveragePredictionRequest.py`) — defer
 - [x] 31. Deadzone scoring weights are magic numbers (`app/services/deadzone.py:284`) — extract to named constants
-- [ ] 32. Raw SQL throughout codebase — migrate to SQLAlchemy (deferred: requires full ORM migration)
+- [x] 32. Raw SQL throughout codebase — migrated to SQLAlchemy ORM
 - [ ] 33. No retry mechanism for failed simulations — user must re-POST (deferred: acceptable for MVP)
 - [ ] 34. PPM image fully loaded into memory for large radius simulations (deferred: rare edge case)
 

app/db/__init__.py

@@ -1,6 +1,6 @@
 """Database module for the LoRa Coverage Planner."""
 
-from app.db.connection import db_connection, get_db
+from app.db.connection import db_session, get_engine, init_engine
 from app.db.schema import init_db
 
-__all__: list[str] = ["db_connection", "get_db", "init_db"]
+__all__: list[str] = ["db_session", "get_engine", "init_engine", "init_db"]

app/db/connection.py

@@ -1,61 +1,73 @@
-"""SQLite connection factory for the LoRa Coverage Planner."""
+"""SQLAlchemy engine and session factory for the LoRa Coverage Planner."""
 
 from __future__ import annotations
 
 import logging
 import os
-import sqlite3
 from collections.abc import Generator
 from contextlib import contextmanager
 from pathlib import Path
 
+from sqlalchemy import Engine, create_engine, event
+from sqlalchemy.orm import Session, sessionmaker
+
 logger = logging.getLogger(__name__)
 
 DEFAULT_DB_PATH: str = "/data/lora-planner.db"
 
+_engine: Engine | None = None
+_session_factory: sessionmaker[Session] | None = None
+
+
+def init_engine(db_path: str | Path | None = None) -> Engine:
+    """Create and configure the SQLAlchemy engine for the given database path.
 
-def get_db(db_path: str | None = None) -> sqlite3.Connection:
-    """Return a configured SQLite connection.
+    Sets WAL journal mode and enables foreign keys on every new connection.
+    Initializes the global engine and session factory used by :func:`db_session`.
 
     Parameters
     ----------
     db_path:
         Filesystem path to the database file.  Falls back to the ``DB_PATH``
         environment variable, then to :data:`DEFAULT_DB_PATH`.
-
-    Returns
-    -------
-    sqlite3.Connection
-        A connection with WAL mode, foreign keys enabled, and
-        ``row_factory`` set to :class:`sqlite3.Row`.
     """
-    resolved_path: Path = Path(db_path or os.environ.get("DB_PATH", DEFAULT_DB_PATH))
+    global _engine, _session_factory
 
-    logger.debug("Opening database connection to %s", resolved_path)
+    resolved = Path(db_path or os.environ.get("DB_PATH", DEFAULT_DB_PATH))
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+    logger.debug("Creating SQLAlchemy engine for %s", resolved)
 
-    conn: sqlite3.Connection = sqlite3.connect(str(resolved_path))
-    conn.execute("PRAGMA journal_mode=WAL;")
-    conn.execute("PRAGMA foreign_keys=ON;")
-    conn.row_factory = sqlite3.Row
+    engine = create_engine(
+        f"sqlite:///{resolved}",
+        connect_args={"check_same_thread": False},
+    )
 
-    return conn
+    @event.listens_for(engine, "connect")
+    def _set_sqlite_pragma(dbapi_conn, connection_record):
+        cursor = dbapi_conn.cursor()
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
 
+    _engine = engine
+    _session_factory = sessionmaker(bind=engine)
+    return engine
 
-@contextmanager
-def db_connection(db_path: str | None = None) -> Generator[sqlite3.Connection, None, None]:
-    """Context manager that yields a configured SQLite connection and closes it on exit.
 
-    Parameters
-    ----------
-    db_path:
-        Filesystem path to the database file.  Passed through to :func:`get_db`.
+def get_engine() -> Engine:
+    """Return the global engine, raising if not yet initialized."""
+    if _engine is None:
+        raise RuntimeError("Database engine not initialized — call init_engine() first")
+    return _engine
 
-    Yields
-    ------
-    sqlite3.Connection
-    """
-    conn = get_db(db_path)
+
+@contextmanager
+def db_session() -> Generator[Session, None, None]:
+    """Context manager that yields a configured SQLAlchemy session and closes it on exit."""
+    if _session_factory is None:
+        raise RuntimeError("Database not initialized — call init_engine() first")
+    session = _session_factory()
     try:
-        yield conn
+        yield session
     finally:
-        conn.close()
+        session.close()

app/db/models.py

@@ -0,0 +1,84 @@
+"""SQLAlchemy ORM models for the LoRa Coverage Planner.
+
+These models define the current schema state used for application queries.
+Schema evolution is handled by the migration system in ``schema.py``.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import JSON, Float, ForeignKey, Index, Integer, LargeBinary, String, Text, UniqueConstraint, text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Tower(Base):
+    __tablename__ = "towers"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    color: Mapped[str | None] = mapped_column(String)
+    params: Mapped[dict] = mapped_column(JSON, nullable=False)
+    geotiff: Mapped[bytes | None] = mapped_column(LargeBinary)
+    created_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))
+    updated_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))
+
+
+class Task(Base):
+    __tablename__ = "tasks"
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    tower_id: Mapped[str] = mapped_column(ForeignKey("towers.id", ondelete="CASCADE"), nullable=False, index=True)
+    status: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'processing'"))
+    error: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))
+
+
+class TowerPath(Base):
+    __tablename__ = "tower_paths"
+    __table_args__ = (
+        UniqueConstraint("tower_a_id", "tower_b_id"),
+        Index("idx_tower_paths_tower_a", "tower_a_id"),
+        Index("idx_tower_paths_tower_b", "tower_b_id"),
+    )
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    tower_a_id: Mapped[str] = mapped_column(ForeignKey("towers.id", ondelete="CASCADE"), nullable=False)
+    tower_b_id: Mapped[str] = mapped_column(ForeignKey("towers.id", ondelete="CASCADE"), nullable=False)
+    path_loss_db: Mapped[float | None] = mapped_column(Float)
+    has_los: Mapped[int | None] = mapped_column(Integer)
+    distance_km: Mapped[float | None] = mapped_column(Float)
+    status: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'pending'"))
+    error: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))
+
+    tower_a: Mapped[Tower] = relationship(foreign_keys=[tower_a_id])
+    tower_b: Mapped[Tower] = relationship(foreign_keys=[tower_b_id])
+
+
+class Simulation(Base):
+    __tablename__ = "simulations"
+    __table_args__ = (
+        UniqueConstraint("tower_id", "client_hardware", "client_antenna", "terrain_model"),
+        Index("idx_simulations_tower_id", "tower_id"),
+    )
+
+    id: Mapped[str] = mapped_column(String, primary_key=True)
+    tower_id: Mapped[str] = mapped_column(ForeignKey("towers.id", ondelete="CASCADE"), nullable=False)
+    client_hardware: Mapped[str] = mapped_column(String, nullable=False)
+    client_antenna: Mapped[str] = mapped_column(String, nullable=False)
+    terrain_model: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'bare_earth'"))
+    status: Mapped[str] = mapped_column(String, nullable=False, server_default=text("'pending'"))
+    geotiff: Mapped[bytes | None] = mapped_column(LargeBinary)
+    error: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))
+
+
+class Setting(Base):
+    __tablename__ = "settings"
+
+    key: Mapped[str] = mapped_column(String, primary_key=True)
+    value: Mapped[str] = mapped_column(Text, nullable=False)
+    updated_at: Mapped[str] = mapped_column(String, nullable=False, server_default=text("(datetime('now'))"))

app/db/schema.py

@@ -1,11 +1,18 @@
-"""SQLite schema definitions and database initialization for the LoRa Coverage Planner."""
+"""SQLite schema definitions and database initialization for the LoRa Coverage Planner.
+
+DDL migrations are applied via raw SQL through the SQLAlchemy engine.  The ORM
+models in ``models.py`` describe the *current* schema state for application
+queries; this module handles schema *evolution*.
+"""
 
 from __future__ import annotations
 
 import logging
 from pathlib import Path
 
-from app.db.connection import db_connection
+from sqlalchemy import text
+
+from app.db.connection import init_engine
 
 logger = logging.getLogger(__name__)
 
@@ -104,6 +111,9 @@
 def init_db(db_path: str | Path) -> None:
     """Create the database file (if needed) and apply all pending schema migrations.
 
+    Also initializes the global SQLAlchemy engine and session factory via
+    :func:`init_engine`, so callers can use :func:`db_session` immediately after.
+
     Each migration is applied inside a single transaction and its version
     number is recorded in the ``schema_version`` table so it is never
     re-applied.
@@ -113,24 +123,22 @@ def init_db(db_path: str | Path) -> None:
     db_path:
         Filesystem path where the SQLite database should be created.
     """
-    db_path = Path(db_path)
-    db_path.parent.mkdir(parents=True, exist_ok=True)
-
     logger.info("Initializing database at %s", db_path)
+    engine = init_engine(db_path)
 
-    with db_connection(str(db_path)) as conn:
+    with engine.connect() as conn:
         # Bootstrap the version-tracking table (always safe to re-run)
-        conn.execute(SCHEMA_VERSION)
+        conn.execute(text(SCHEMA_VERSION))
 
-        current = conn.execute("SELECT COALESCE(MAX(version), 0) FROM schema_version").fetchone()[0]
+        current = conn.execute(text("SELECT COALESCE(MAX(version), 0) FROM schema_version")).scalar()
         logger.info("Current schema version: %s", current)
 
         for version, statements in MIGRATIONS:
             if version <= current:
                 continue
             for stmt in statements:
-                conn.execute(stmt)
-            conn.execute("INSERT INTO schema_version (version) VALUES (?)", (version,))
+                conn.execute(text(stmt))
+            conn.execute(text("INSERT INTO schema_version (version) VALUES (:v)"), {"v": version})
             logger.info("Applied schema migration v%s", version)
 
         conn.commit()