Implement per-session in-memory database caching and update app secret key handling

- Added support for per-session in-memory SQLite databases, allowing each browser session to have its own isolated database.
- Introduced a unique session ID for database connections using Flask sessions.
- Updated the default port in app.py from 7860 to 5001 for consistency.
- Refactored database initialization to accommodate the new caching mechanism.

app.py

@@ -12,13 +12,15 @@ import csv
 import io
 import json
 import re
+import uuid
 import zipfile
 from datetime import date
 from pathlib import Path
 
-from flask import Flask, render_template, jsonify, request, redirect, url_for, Response
+from flask import Flask, render_template, jsonify, request, redirect, url_for, Response, session
 from google import genai
 
+import database   # imported as module so we can write to database.session_local
 from database import (
     init_db,
     create_source, get_source, get_all_sources, delete_source,
@@ -32,6 +34,24 @@ from tei import source_to_tei, tei_to_source_data
 
 app = Flask(__name__)
 
+# Flask sessions need a secret key for signing the session cookie.
+# In production set SD_SECRET_KEY in the environment; otherwise a random
+# key is generated at startup (sessions survive only while the server runs).
+app.secret_key = os.environ.get("SD_SECRET_KEY") or os.urandom(32)
+
+_CACHE_MODE = bool(os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB"))
+
+
+@app.before_request
+def _bind_session_db():
+    """Assign (and persist) a unique DB session ID for this browser session."""
+    if not _CACHE_MODE:
+        return
+    if "_db_sid" not in session:
+        session["_db_sid"] = str(uuid.uuid4())
+        session.permanent = True           # honour PERMANENT_SESSION_LIFETIME
+    database.session_local.session_id = session["_db_sid"]
+
 PROJECT_ROOT = Path(__file__).resolve().parent
 BIBLE_TSV_PATH = PROJECT_ROOT / "data" / "bible.tsv"
 BOOK_MAPPING_PATH = PROJECT_ROOT / "data" / "book_mapping.tsv"
@@ -721,7 +741,7 @@ init_db()
 if __name__ == "__main__":
     _cache_db = bool(os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB"))
     _host  = os.environ.get("SD_HOST", "127.0.0.1")
-    _port  = int(os.environ.get("SD_PORT", "7860"))
+    _port  = int(os.environ.get("SD_PORT", "5001"))
     # Disable the reloader in cache-db mode: the reloader forks the process,
     # which would create a fresh in-memory database and lose all data.
     _debug = not _cache_db

database.py

@@ -2,6 +2,7 @@ import os
 import sqlite3
 import re
 import threading
+import time
 from pathlib import Path
 from contextlib import contextmanager
 
@@ -13,39 +14,100 @@ DB_PATH = (
     else Path(__file__).resolve().parent / "scripture_detector.db"
 )
 
-# ── cache-db (in-memory) mode ─────────────────────────────────────────────────
-# Enabled by setting env var SCRIPTURE_DETECTOR_CACHE_DB=1 before this module
-# is imported.  app.py sets this when --cache-db flag is present.
-_CACHE_MODE: bool = os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB", "") in ("1", "true", "yes")
-_cache_conn: sqlite3.Connection | None = None
-_cache_lock: threading.Lock = threading.Lock()
-
+# ── cache-db (per-session in-memory) mode ────────────────────────────────────
+# Enabled by SCRIPTURE_DETECTOR_CACHE_DB=1 (set by app.py when --cache-db is
+# passed).  Each browser session gets its own isolated SQLite :memory: database.
+# Sessions are keyed by a UUID stored in the signed Flask session cookie and
+# cleaned up after SESSION_TTL seconds of inactivity.
 
-def _make_cache_connection() -> sqlite3.Connection:
+_CACHE_MODE: bool = os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB", "") in ("1", "true", "yes")
+SESSION_TTL: int  = int(os.environ.get("SD_SESSION_TTL", "3600"))  # default 1 hour
+
+# Maps session_id → {conn, lock, last_used}
+_sessions: dict[str, dict] = {}
+_sessions_lock = threading.Lock()
+
+# Thread-local holds the current session_id (set by app.py before_request hook)
+session_local = threading.local()
+
+
+_SCHEMA_SQL = """
+    CREATE TABLE IF NOT EXISTS sources (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        text TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE IF NOT EXISTS quotes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_id INTEGER NOT NULL,
+        span_start INTEGER,
+        span_end INTEGER,
+        quote_text TEXT NOT NULL,
+        quote_type TEXT NOT NULL DEFAULT 'allusion'
+            CHECK(quote_type IN ('full','partial','paraphrase','allusion')),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (source_id) REFERENCES sources(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS quote_references (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        quote_id INTEGER NOT NULL,
+        reference TEXT NOT NULL,
+        book_code TEXT,
+        FOREIGN KEY (quote_id) REFERENCES quotes(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+    );
+"""
+
+
+def _new_session_conn() -> sqlite3.Connection:
+    """Create a fresh in-memory SQLite connection with the full schema."""
     conn = sqlite3.connect(":memory:", check_same_thread=False)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA foreign_keys = ON")
+    conn.executescript(_SCHEMA_SQL)
+    conn.commit()
     return conn
 
 
-def get_connection() -> sqlite3.Connection:
-    global _cache_conn
-    if _CACHE_MODE:
-        if _cache_conn is None:
-            _cache_conn = _make_cache_connection()
-        return _cache_conn
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    conn.execute("PRAGMA foreign_keys = ON")
-    return conn
+def _get_session_entry(session_id: str) -> dict:
+    """Return (and lazily create) the session entry for *session_id*."""
+    with _sessions_lock:
+        # Prune idle sessions
+        now = time.monotonic()
+        stale = [sid for sid, s in _sessions.items()
+                 if now - s["last_used"] > SESSION_TTL]
+        for sid in stale:
+            try:
+                _sessions[sid]["conn"].close()
+            except Exception:
+                pass
+            del _sessions[sid]
+
+        if session_id not in _sessions:
+            _sessions[session_id] = {
+                "conn":      _new_session_conn(),
+                "lock":      threading.Lock(),
+                "last_used": now,
+            }
+        else:
+            _sessions[session_id]["last_used"] = now
+
+        return _sessions[session_id]
 
 
 @contextmanager
 def get_db():
     if _CACHE_MODE:
-        # Serialise access to the single in-memory connection.
-        with _cache_lock:
-            conn = get_connection()
+        sid   = getattr(session_local, "session_id", None) or "anonymous"
+        entry = _get_session_entry(sid)
+        with entry["lock"]:
+            conn = entry["conn"]
             try:
                 yield conn
                 conn.commit()
@@ -53,7 +115,9 @@ def get_db():
                 conn.rollback()
                 raise
     else:
-        conn = get_connection()
+        conn = sqlite3.connect(str(DB_PATH))
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA foreign_keys = ON")
         try:
             yield conn
             conn.commit()
@@ -65,39 +129,12 @@ def get_db():
 
 
 def init_db():
+    if _CACHE_MODE:
+        # In cache mode each session's schema is initialised when its
+        # connection is first created (_new_session_conn).  Nothing to do here.
+        return
     with get_db() as conn:
-        conn.executescript("""
-            CREATE TABLE IF NOT EXISTS sources (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL,
-                text TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            );
-            CREATE TABLE IF NOT EXISTS quotes (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                source_id INTEGER NOT NULL,
-                span_start INTEGER,
-                span_end INTEGER,
-                quote_text TEXT NOT NULL,
-                quote_type TEXT NOT NULL DEFAULT 'allusion'
-                    CHECK(quote_type IN ('full','partial','paraphrase','allusion')),
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (source_id) REFERENCES sources(id) ON DELETE CASCADE
-            );
-            CREATE TABLE IF NOT EXISTS quote_references (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                quote_id INTEGER NOT NULL,
-                reference TEXT NOT NULL,
-                book_code TEXT,
-                FOREIGN KEY (quote_id) REFERENCES quotes(id) ON DELETE CASCADE
-            );
-            CREATE TABLE IF NOT EXISTS settings (
-                key TEXT PRIMARY KEY,
-                value TEXT NOT NULL
-            );
-        """)
+        conn.executescript(_SCHEMA_SQL)
 
 
 def extract_book_code(reference: str) -> str: