Sync from GitHub via hub-sync

api/v1/analyze.py

@@ -98,6 +98,13 @@ def _compute_llm_summary(resp, *, record_id: int, user, media_kind: str, exclude
         return None
 
 
+def _persist_response_payload(db: Session, record: AnalysisRecord, resp) -> None:
+    """Keep reloaded/history responses aligned with the fresh API response."""
+    record.result_json = json.dumps(resp.model_dump())
+    db.add(record)
+    db.commit()
+
+
 @router.post("/image", response_model=ImageAnalysisResponse)
 @limiter.limit(ANON_ANALYZE, exempt_when=is_authed)
 @limiter.limit(AUTH_ANALYZE, exempt_when=is_anon)
@@ -288,6 +295,8 @@ async def analyze_image(
         except Exception as e:  # noqa: BLE001
             logger.warning(f"VLM breakdown failed, continuing: {e}")
 
+    resp.processing_summary.stages_completed = stages
+    _persist_response_payload(db, record, resp)
     return resp
 
 
@@ -476,6 +485,8 @@ async def analyze_video_endpoint(
     if llm:
         resp.llm_summary = llm
 
+    resp.processing_summary.stages_completed = stages
+    _persist_response_payload(db, record, resp)
     return resp
 
 
@@ -616,6 +627,8 @@ async def analyze_text_endpoint(
     if llm:
         resp.llm_summary = llm
 
+    resp.processing_summary.stages_completed = stages
+    _persist_response_payload(db, record, resp)
     return resp
 
 
@@ -799,6 +812,8 @@ async def analyze_screenshot_endpoint(
     if llm:
         resp.llm_summary = llm
 
+    resp.processing_summary.stages_completed = stages
+    _persist_response_payload(db, record, resp)
     return resp
 
 
@@ -967,6 +982,7 @@ async def analyze_video_async(
 
 
 @router.post("/audio", response_model=AudioAnalysisResponse)
+@limiter.limit(ANON_ANALYZE, exempt_when=is_authed)
 @limiter.limit(AUTH_ANALYZE, exempt_when=is_anon)
 async def analyze_audio_endpoint(
     request: Request,
@@ -1042,34 +1058,57 @@ async def analyze_audio_endpoint(
     ml_prob = ml_score["fake_probability"]
     final_prob = 0.5 * heuristics_prob + 0.5 * ml_prob
 
-    if final_prob > 0.65:
-        verdict = Verdict.VERY_LIKELY_FAKE
-    elif final_prob > 0.45:
-        verdict = Verdict.SUSPICIOUS
-    else:
-        verdict = Verdict.LIKELY_REAL
+    score = int(round(max(0.0, min(100.0, (1.0 - final_prob) * 100.0))))
+    label, severity = get_verdict_label(score)
 
     resp = AudioAnalysisResponse(
         analysis_id=str(uuid.uuid4()),
         timestamp=datetime.now(timezone.utc).isoformat(),
-        verdict=verdict,
+        verdict=Verdict(
+            label=label,
+            severity=severity,
+            authenticity_score=score,
+            model_confidence=final_prob,
+            model_label="Deepfake-audio-detection-V2"
+        ),
         explainability=audio_expl,
         processing_summary=ProcessingSummary(
-            total_time_ms=int((time.perf_counter() - start) * 1000),
-            stages=stages,
+            stages_completed=stages,
+            total_duration_ms=int((time.perf_counter() - start) * 1000),
+            model_used="MelodyMachine/Deepfake-audio-detection-V2",
+            models_used=["MelodyMachine/Deepfake-audio-detection-V2", "audio-signal-heuristics"],
+            calibrator_applied=False,
         )
     )
 
-    stages.append("llm_summary")
-    resp = _compute_llm_summary(resp, record_id=0, user=user, media_kind="audio_deepfake_analysis")
+    ext = (mime.split("/")[-1] if mime else "mp3").replace("mpeg", "mp3").replace("x-wav", "wav")
+    try:
+        media_path = save_bytes(raw, media_hash, ext)
+    except Exception as e:  # noqa: BLE001
+        logger.warning(f"audio media save failed: {e}")
+        media_path = None
 
-    rec_id, stored_url = store_and_save(
-        db, user, raw, media_hash, "audio", resp, file_ext="mp3"
+    record = AnalysisRecord(
+        user_id=user.id if user else None,
+        media_type="audio",
+        verdict=label,
+        authenticity_score=float(score),
+        result_json=json.dumps(resp.model_dump()),
+        media_hash=media_hash,
+        media_path=media_path,
     )
-    resp.record_id = rec_id
-    if stored_url:
-        resp.thumbnail_url = stored_url
+    db.add(record)
+    db.commit()
+    db.refresh(record)
+    resp.record_id = record.id
+
+    llm = _compute_llm_summary(resp, record_id=record.id, user=user, media_kind="audio_deepfake_analysis")
+    if llm:
+        resp.llm_summary = llm
+        stages.append("llm_summary")
 
+    resp.processing_summary.stages_completed = stages
+    _persist_response_payload(db, record, resp)
     return resp
 
 

api/v1/history.py

@@ -7,7 +7,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, status
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
-from api.deps import get_current_user
+from api.deps import get_current_user, optional_current_user
 from db.database import get_db
 from db.models import AnalysisRecord, User
 
@@ -55,12 +55,22 @@ def list_history(
 @router.get("/{record_id}")
 def get_history_detail(
     record_id: int,
-    user: User = Depends(get_current_user),
+    token: str | None = Query(None),
+    user: User | None = Depends(optional_current_user),
     db: Session = Depends(get_db),
 ):
     r = db.query(AnalysisRecord).filter(AnalysisRecord.id == record_id).first()
-    if not r or r.user_id != user.id:
+    if not r:
         raise HTTPException(status.HTTP_404_NOT_FOUND, "Analysis not found")
+    if user is None or r.user_id != user.id:
+        if r.user_id is not None or not token:
+            raise HTTPException(status.HTTP_404_NOT_FOUND, "Analysis not found")
+        try:
+            token_payload = json.loads(r.result_json)
+        except Exception:
+            raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR, "Corrupt result payload")
+        if token_payload.get("analysis_id") != token:
+            raise HTTPException(status.HTTP_404_NOT_FOUND, "Analysis not found")
     try:
         payload = json.loads(r.result_json)
         # Inject storage fields from DB columns so the frontend can display full-size media

tests/test_api_regressions.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+os.environ["DEBUG"] = "false"
+
+from api.v1.analyze import _persist_response_payload
+from api.v1.history import get_history_detail
+from db.models import AnalysisRecord
+from db.database import Base
+from schemas.analyze import TextAnalysisResponse, TextExplainability
+from schemas.common import LLMExplainabilitySummary, ProcessingSummary, Verdict
+
+
+@pytest.fixture()
+def db_session():
+    engine = create_engine("sqlite:///:memory:", connect_args={"check_same_thread": False})
+    Base.metadata.create_all(bind=engine)
+    Session = sessionmaker(bind=engine)
+    db = Session()
+    try:
+        yield db
+    finally:
+        db.close()
+        Base.metadata.drop_all(bind=engine)
+
+
+def test_anonymous_history_detail_accepts_matching_analysis_token(db_session):
+    payload = {
+        "analysis_id": "public-token",
+        "media_type": "text",
+        "verdict": {"label": "Likely Real", "authenticity_score": 80},
+    }
+    record = AnalysisRecord(
+        user_id=None,
+        media_type="text",
+        verdict="Likely Real",
+        authenticity_score=80,
+        result_json=json.dumps(payload),
+    )
+    db_session.add(record)
+    db_session.commit()
+    db_session.refresh(record)
+
+    result = get_history_detail(record.id, token="public-token", user=None, db=db_session)
+
+    assert result["analysis_id"] == "public-token"
+
+
+def test_anonymous_history_detail_rejects_missing_analysis_token(db_session):
+    record = AnalysisRecord(
+        user_id=None,
+        media_type="text",
+        verdict="Likely Real",
+        authenticity_score=80,
+        result_json=json.dumps({"analysis_id": "public-token"}),
+    )
+    db_session.add(record)
+    db_session.commit()
+    db_session.refresh(record)
+
+    with pytest.raises(Exception):
+        get_history_detail(record.id, token=None, user=None, db=db_session)
+
+
+def test_persist_response_payload_keeps_postprocessing_fields_for_reload(db_session):
+    record = AnalysisRecord(
+        user_id=1,
+        media_type="text",
+        verdict="Likely Real",
+        authenticity_score=80,
+        result_json="{}",
+    )
+    db_session.add(record)
+    db_session.commit()
+    db_session.refresh(record)
+
+    resp = TextAnalysisResponse(
+        analysis_id="analysis-1",
+        record_id=record.id,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        verdict=Verdict(
+            label="Likely Real",
+            severity="positive",
+            authenticity_score=80,
+            model_confidence=0.2,
+            model_label="real",
+        ),
+        explainability=TextExplainability(fake_probability=0.2, top_label="real"),
+        llm_summary=LLMExplainabilitySummary(paragraph="Persisted explanation"),
+        processing_summary=ProcessingSummary(
+            stages_completed=["classification", "llm_explanation"],
+            total_duration_ms=12,
+            model_used="test-model",
+        ),
+    )
+
+    _persist_response_payload(db_session, record, resp)
+
+    db_session.refresh(record)
+    stored = json.loads(record.result_json)
+    assert stored["record_id"] == record.id
+    assert stored["llm_summary"]["paragraph"] == "Persisted explanation"
+    assert stored["processing_summary"]["stages_completed"] == ["classification", "llm_explanation"]