| import time |
|
|
| from fastapi import APIRouter, HTTPException, Query |
|
|
| from src.api.schemas import ( |
| BatchPredictRequest, |
| BatchPredictResponse, |
| PredictRequest, |
| PredictResponse, |
| VideoRequest, |
| VideoResponse, |
| ) |
| from src.api.services import predict_single, to_predict_response |
| from src.api.state import get_state |
| from src.api.youtube import CommentsFetchError, extract_video_id, fetch_comments |
| from src.db.supabase_client import list_predictions, save_prediction |
|
|
| router = APIRouter(tags=["Prediction"]) |
|
|
|
|
| @router.post("/predict", response_model=PredictResponse) |
| async def predict(request: PredictRequest): |
| response = predict_single(request.text, request.threshold) |
| save_prediction( |
| text=request.text, |
| result=response, |
| source="api_direct", |
| threshold=request.threshold, |
| latency_ms=response.latency_ms, |
| ) |
| return response |
|
|
|
|
| @router.post("/predict-batch", response_model=BatchPredictResponse) |
| async def predict_batch(request: BatchPredictRequest): |
| t0 = time.perf_counter() |
| results: list[PredictResponse] = [] |
| for text in request.texts: |
| if not text.strip(): |
| continue |
| single = predict_single(text.strip(), request.threshold) |
| results.append(single) |
| save_prediction( |
| text=text.strip(), |
| result=single, |
| source="api_direct", |
| threshold=request.threshold, |
| latency_ms=single.latency_ms, |
| ) |
| total_ms = round((time.perf_counter() - t0) * 1000, 2) |
| toxic_count = sum(1 for r in results if r.is_toxic) |
| return BatchPredictResponse( |
| results=results, |
| total=len(results), |
| toxic_count=toxic_count, |
| latency_ms=total_ms, |
| ) |
|
|
|
|
| @router.post("/predict-video", response_model=VideoResponse) |
| async def predict_video(request: VideoRequest): |
| try: |
| comments, source = fetch_comments(request.url, request.max_comments) |
| except CommentsFetchError as exc: |
| raise HTTPException(status_code=422, detail=str(exc)) from exc |
| except Exception as exc: |
| raise HTTPException(status_code=422, detail=f"Failed to fetch comments: {exc}") from exc |
|
|
| if not comments: |
| raise HTTPException(status_code=404, detail="No comments found for this video") |
|
|
| video_id = extract_video_id(request.url) |
|
|
| t0 = time.perf_counter() |
| results: list[PredictResponse] = [] |
| service = get_state()["service"] |
| if service is None: |
| raise HTTPException(status_code=503, detail="Model not loaded") |
|
|
| for text in comments: |
| if not text.strip(): |
| continue |
| raw = service.predict(text) |
| response = to_predict_response(text, raw, 0.0, request.threshold) |
| results.append(response) |
| save_prediction( |
| text=text, |
| result=response, |
| source="video_fetch", |
| video_id=video_id, |
| video_url=request.url, |
| threshold=request.threshold, |
| latency_ms=response.latency_ms, |
| ) |
|
|
| total_ms = round((time.perf_counter() - t0) * 1000, 2) |
| toxic_count = sum(1 for r in results if r.is_toxic) |
| get_state()["predictions_served"] = get_state().get("predictions_served", 0) + len(results) |
|
|
| return VideoResponse( |
| video_url=request.url, |
| total_fetched=len(results), |
| toxic_count=toxic_count, |
| toxic_rate=round(toxic_count / len(results), 4) if results else 0.0, |
| results=results, |
| source=source, |
| ) |
|
|
|
|
| @router.get("/predictions") |
| async def get_predictions( |
| video_id: str | None = Query(default=None), |
| limit: int = Query(default=50, ge=1, le=200), |
| ): |
| rows = list_predictions(video_id=video_id, limit=limit) |
| return rows |
|
|
