feat: add TMDB integration and movie endpoints

.gitignore

@@ -12,3 +12,5 @@ wheels/
 results/
 
 __huggingface_repos__.json
+
+.env

main.py

@@ -1,10 +1,17 @@
 import time
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, HTTPException
+import httpx
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from transformers import pipeline
 
+from tmdb import fetch_reviews, search_movies
+
+load_dotenv()
+
 MODEL_PATH = "./results/best_model"
 
 ml: dict = {}
@@ -32,6 +39,14 @@ app = FastAPI(
     lifespan=lifespan,
 )
 
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 class PredictRequest(BaseModel):
     text: str = Field(
@@ -63,6 +78,35 @@ class BatchResponse(BaseModel):
     total_latency_ms: float
 
 
+class MovieResult(BaseModel):
+    id: int
+    title: str
+    release_year: int | None
+    poster_url: str | None
+    tmdb_rating: float | None
+
+
+class MovieSearchResponse(BaseModel):
+    results: list[MovieResult]
+
+
+class ReviewResult(BaseModel):
+    id: str
+    author: str
+    content: str
+    author_rating: float | None
+    created_at: str
+    sentiment_label: str
+    sentiment_score: float
+
+
+class MovieReviewsResponse(BaseModel):
+    movie_id: int
+    title: str
+    review_count: int
+    reviews: list[ReviewResult]
+
+
 @app.get("/", tags=["health"])
 def health():
     return {"status": "ok", "model": MODEL_PATH}
@@ -105,3 +149,69 @@ def predict_batch(req: BatchRequest):
     ]
 
     return BatchResponse(results=results, total_latency_ms=round(total_latency, 2))
+
+
+@app.get("/movies/search", response_model=MovieSearchResponse, tags=["movies"])
+async def movies_search(q: str = Query(..., min_length=1)):
+    try:
+        movies = await search_movies(q)
+    except httpx.HTTPStatusError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+    except httpx.TimeoutException as exc:
+        raise HTTPException(status_code=504, detail="TMDB request timed out") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    return MovieSearchResponse(results=[MovieResult(**m) for m in movies])
+
+
+@app.get(
+    "/movies/{movie_id}/reviews", response_model=MovieReviewsResponse, tags=["movies"]
+)
+async def movies_reviews(movie_id: int):
+    if "pipe" not in ml:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+
+    try:
+        title, reviews = await fetch_reviews(movie_id)
+    except httpx.HTTPStatusError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+    except httpx.TimeoutException as exc:
+        raise HTTPException(status_code=504, detail="TMDB request timed out") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    if not reviews:
+        return MovieReviewsResponse(
+            movie_id=movie_id, title=title, review_count=0, reviews=[]
+        )
+
+    # Truncate to 512 chars for inference, keep full content for response
+    truncated = [r["content"][:512] for r in reviews]
+
+    # Run inference in chunks of 32
+    chunk_size = 32
+    predictions: list[dict] = []
+    for i in range(0, len(truncated), chunk_size):
+        chunk = truncated[i : i + chunk_size]
+        predictions.extend(ml["pipe"](chunk))
+
+    review_results = [
+        ReviewResult(
+            id=review["id"],
+            author=review["author"],
+            content=review["content"],
+            author_rating=review["author_rating"],
+            created_at=review["created_at"],
+            sentiment_label=pred["label"],
+            sentiment_score=round(pred["score"], 4),
+        )
+        for review, pred in zip(reviews, predictions)
+    ]
+
+    return MovieReviewsResponse(
+        movie_id=movie_id,
+        title=title,
+        review_count=len(review_results),
+        reviews=review_results,
+    )

pyproject.toml

@@ -12,6 +12,8 @@ dependencies = [
     "scikit-learn>=1.4.0",
     "fastapi>=0.111.0",
     "uvicorn[standard]>=0.29.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
 ]
 
 [dependency-groups]

tmdb.py

@@ -0,0 +1,75 @@
+import os
+
+import httpx
+
+TMDB_BASE_URL = "https://api.themoviedb.org/3"
+TMDB_IMAGE_BASE = "https://image.tmdb.org/t/p/w200"
+MAX_REVIEW_PAGES = 5
+
+
+def _get_auth_headers() -> dict:
+    token = os.environ.get("TMDB_API_KEY")
+    if not token:
+        raise ValueError("TMDB_API_KEY environment variable is not set")
+    return {"Authorization": f"Bearer {token}", "accept": "application/json"}
+
+
+async def search_movies(query: str) -> list[dict]:
+    headers = _get_auth_headers()
+    async with httpx.AsyncClient(timeout=10, headers=headers) as client:
+        response = await client.get(
+            f"{TMDB_BASE_URL}/search/movie",
+            params={"query": query, "language": "en-US", "page": 1},
+        )
+        response.raise_for_status()
+        data = response.json()
+
+    results = []
+    for movie in data.get("results", []):
+        release_date = movie.get("release_date") or ""
+        release_year = int(release_date[:4]) if len(release_date) >= 4 else None
+        poster_path = movie.get("poster_path")
+        poster_url = f"{TMDB_IMAGE_BASE}{poster_path}" if poster_path else None
+        results.append(
+            {
+                "id": movie["id"],
+                "title": movie["title"],
+                "release_year": release_year,
+                "poster_url": poster_url,
+                "tmdb_rating": movie.get("vote_average"),
+            }
+        )
+    return results
+
+
+async def fetch_reviews(movie_id: int) -> tuple[str, list[dict]]:
+    headers = _get_auth_headers()
+    async with httpx.AsyncClient(timeout=10, headers=headers) as client:
+        movie_resp = await client.get(f"{TMDB_BASE_URL}/movie/{movie_id}")
+        movie_resp.raise_for_status()
+        title = movie_resp.json().get("title", "")
+
+        reviews: list[dict] = []
+        for page in range(1, MAX_REVIEW_PAGES + 1):
+            rev_resp = await client.get(
+                f"{TMDB_BASE_URL}/movie/{movie_id}/reviews",
+                params={"page": page},
+            )
+            rev_resp.raise_for_status()
+            rev_data = rev_resp.json()
+            page_results = rev_data.get("results", [])
+            for r in page_results:
+                author_details = r.get("author_details") or {}
+                reviews.append(
+                    {
+                        "id": r["id"],
+                        "author": r.get("author", ""),
+                        "content": r.get("content", ""),
+                        "author_rating": author_details.get("rating"),
+                        "created_at": r.get("created_at", ""),
+                    }
+                )
+            if len(page_results) == 0 or rev_data.get("page", 1) >= rev_data.get("total_pages", 1):
+                break
+
+    return title, reviews

uv.lock

@@ -775,6 +775,8 @@ dependencies = [
     { name = "datasets" },
     { name = "evaluate" },
     { name = "fastapi" },
+    { name = "httpx" },
+    { name = "python-dotenv" },
     { name = "scikit-learn", version = "1.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
     { name = "scikit-learn", version = "1.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "torch" },
@@ -793,6 +795,8 @@ requires-dist = [
     { name = "datasets", specifier = ">=2.19.0" },
     { name = "evaluate", specifier = ">=0.4.1" },
     { name = "fastapi", specifier = ">=0.111.0" },
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "scikit-learn", specifier = ">=1.4.0" },
     { name = "torch", specifier = ">=2.2.0" },
     { name = "transformers", specifier = ">=4.40.0" },