chore: remove unused database/SQLAlchemy dependency

App only uses JSON APIs - no database needed.
Removes sqlalchemy, pymysql, database.py, handbook_repo.py.
Reduces Docker image size and eliminates DB connection failures.

app/core/config.py

@@ -14,14 +14,6 @@ class Settings(BaseSettings):
     debug: bool = False
     port: int = 7860  # Hugging Face Spaces default
 
-    # Database
-    db_host: str = "localhost"
-    db_port: int = 3306
-    db_user: str = "root"
-    db_password: str = ""
-    db_name: str = "handbook"
-    db_charset: str = "utf8mb4"
-
     # External API endpoints (the source-of-truth JSON APIs)
     handbook_general_endpoint: str = ""
     university_handbook_endpoint: str = ""
@@ -43,14 +35,6 @@ class Settings(BaseSettings):
 
     model_config = {"env_file": ".env", "env_file_encoding": "utf-8", "extra": "ignore"}
 
-    @property
-    def database_url(self) -> str:
-        return (
-            f"mysql+pymysql://{self.db_user}:{self.db_password}"
-            f"@{self.db_host}:{self.db_port}/{self.db_name}"
-            f"?charset={self.db_charset}"
-        )
-
     @property
     def cors_origins_list(self) -> list[str]:
         return [o.strip() for o in self.cors_origins.split(",") if o.strip()]

app/core/database.py

@@ -1,48 +0,0 @@
-"""Database engine and session factory (SQLAlchemy).
-
-Engine is created lazily to avoid crash on startup when no DB is available
-(e.g. Hugging Face Spaces without MySQL).
-"""
-
-import logging
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, DeclarativeBase
-
-from app.core.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-
-class Base(DeclarativeBase):
-    pass
-
-
-_engine = None
-
-
-def _get_engine():
-    global _engine
-    if _engine is None:
-        _settings = get_settings()
-        try:
-            _engine = create_engine(
-                _settings.database_url,
-                pool_pre_ping=True,
-                pool_recycle=3600,
-                echo=_settings.debug,
-            )
-        except Exception as exc:
-            logger.warning("Database engine creation failed: %s", exc)
-            raise
-    return _engine
-
-
-def get_db():
-    """FastAPI dependency: yields a DB session, closes on exit."""
-    engine = _get_engine()
-    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-    db = Session()
-    try:
-        yield db
-    finally:
-        db.close()

app/repositories/handbook_repo.py

@@ -1,124 +0,0 @@
-"""Repository layer — direct DB access if needed.
-
-The PHP code primarily fetches data over HTTP from two JSON APIs rather than
-querying the database directly. This repository provides a DB-backed fallback
-for when the Python service needs to read from MySQL directly (e.g., if the
-external endpoints are unreachable or the service is meant to replace them).
-
-ASSUMPTION: The database tables match the JSON structures returned by the PHP
-endpoints. Table/column names are preserved exactly.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any
-
-from sqlalchemy import text
-from sqlalchemy.orm import Session
-
-logger = logging.getLogger(__name__)
-
-
-class HandbookRepository:
-    """Read-only queries against the existing MySQL schema."""
-
-    def __init__(self, db: Session):
-        self.db = db
-
-    # ── Global / general sections ──
-
-    def get_general_sections(self, catalog_id: int = 0) -> list[dict[str, Any]]:
-        """Fetch handbook_general_sections rows.
-
-        ASSUMPTION: Table is named `handbook_general_sections` with columns:
-        id, section_key, section_title, section_json, sort_order, catalog_id.
-        Adjust if the actual schema differs.
-        """
-        query = text(
-            "SELECT id, section_key, section_title, section_json, sort_order "
-            "FROM handbook_general_sections "
-            "WHERE (:catalog_id = 0 OR catalog_id = :catalog_id) "
-            "ORDER BY sort_order ASC, id ASC"
-        )
-        rows = self.db.execute(query, {"catalog_id": catalog_id}).mappings().all()
-        results = []
-        for row in rows:
-            section_json = row.get("section_json", "{}")
-            if isinstance(section_json, str):
-                try:
-                    section_json = json.loads(section_json) if section_json.strip() else {}
-                except (json.JSONDecodeError, ValueError):
-                    logger.warning(
-                        "Failed to parse section_json for id=%s key=%s",
-                        row.get("id"),
-                        row.get("section_key"),
-                    )
-                    section_json = {}
-
-            results.append(
-                {
-                    "id": row["id"],
-                    "section_key": row.get("section_key", ""),
-                    "section_title": row.get("section_title", ""),
-                    "section_json": section_json,
-                    "sort_order": row.get("sort_order"),
-                }
-            )
-        return results
-
-    # ── University sections ──
-
-    def get_university_sections(self) -> list[dict[str, Any]]:
-        """Fetch university data with their sections.
-
-        ASSUMPTION: Tables `universities` and `university_handbook_sections` exist.
-        Adjust table/column names to match the real schema.
-        """
-        uni_query = text(
-            "SELECT id AS university_id, university_name, is_active, website "
-            "FROM universities "
-            "ORDER BY university_name ASC"
-        )
-        unis = self.db.execute(uni_query).mappings().all()
-
-        results = []
-        for uni in unis:
-            uid = uni["university_id"]
-            sec_query = text(
-                "SELECT id, section_key, section_title, section_json "
-                "FROM university_handbook_sections "
-                "WHERE university_id = :uid "
-                "ORDER BY sort_order ASC, id ASC"
-            )
-            sec_rows = self.db.execute(sec_query, {"uid": uid}).mappings().all()
-
-            sections = []
-            for s in sec_rows:
-                sj = s.get("section_json", "{}")
-                if isinstance(sj, str):
-                    try:
-                        sj = json.loads(sj) if sj.strip() else {}
-                    except (json.JSONDecodeError, ValueError):
-                        sj = {}
-                sections.append(
-                    {
-                        "id": s["id"],
-                        "section_key": s.get("section_key", ""),
-                        "section_title": s.get("section_title", ""),
-                        "section_json": sj,
-                    }
-                )
-
-            results.append(
-                {
-                    "university_id": uid,
-                    "university_name": uni.get("university_name", ""),
-                    "is_active": bool(uni.get("is_active", True)),
-                    "website": uni.get("website", ""),
-                    "sections": sections,
-                }
-            )
-
-        return results

requirements.txt

@@ -2,8 +2,6 @@ fastapi>=0.110.0
 uvicorn[standard]>=0.27.0
 pydantic>=2.5.0
 pydantic-settings>=2.1.0
-sqlalchemy>=2.0.0
-pymysql>=1.1.0
 httpx>=0.27.0
 jinja2>=3.1.0
 markupsafe>=2.1.0