Update server.py

server.py

@@ -8,16 +8,10 @@ import hashlib
 import httpx
 import os
 import base64
-import asyncio
 import json
 
 # ---------------- API KEYS ----------------
-HF_API_KEY = os.getenv("HF_API_KEY")
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-
-# ---------------- CLOUD MODELS ----------------
-CLOUD_MODEL_1 = "https://router.huggingface.co/hf-inference/models/Ateeqq/ai-vs-human-image-detector"
-CLOUD_MODEL_2 = "https://router.huggingface.co/hf-inference/models/prithivMLmods/deepfake-detector-model-v1"
 GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
 
 # ---------------- APP ----------------
@@ -65,55 +59,10 @@ def fusion_score(model_score: float, metadata_risk: float):
     return authenticity, fake
 
 
-def normalize_output(label_prob_dict: dict) -> float:
-    FAKE_KEYWORDS = ["fake", "ai", "generated", "manipulated", "deepfake", "artificial", "synthetic"]
-    REAL_KEYWORDS = ["real", "authentic", "genuine", "human", "original"]
-
-    fake_score = 0.0
-    uncertain_score = 0.0
-
-    for label, prob in label_prob_dict.items():
-        label_lower = label.lower()
-        if any(k in label_lower for k in FAKE_KEYWORDS):
-            fake_score += prob
-        elif any(k in label_lower for k in REAL_KEYWORDS):
-            pass
-        else:
-            uncertain_score += prob
-
-    fake_score += 0.4 * uncertain_score
-    return min(fake_score, 1.0)
-
-
 # ==============================
-# CLOUD MODEL CALLS
+# GROQ VISION
 # ==============================
 
-async def call_model(url: str, contents: bytes, name: str, content_type: str = "image/jpeg") -> Optional[float]:
-    if not HF_API_KEY:
-        print(f"No HF_API_KEY, skipping {name}")
-        return None
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                url,
-                headers={
-                    "Authorization": f"Bearer {HF_API_KEY}",
-                    "Content-Type": content_type
-                },
-                content=contents,
-            )
-            print(f"{name} status: {response.status_code}")
-            print(f"{name} response: {response.text}")
-            response.raise_for_status()
-            data = response.json()
-            label_prob_dict = {item["label"]: item["score"] for item in data}
-            return normalize_output(label_prob_dict)
-    except Exception as e:
-        print(f"{name} failed: {e}")
-        return None
-
-
 async def call_groq_vision(contents: bytes) -> Optional[float]:
     if not GROQ_API_KEY:
         print("No GROQ_API_KEY set")
@@ -188,37 +137,16 @@ fake_probability must be between 0.0 (definitely real) and 1.0 (definitely AI/fa
 async def analyze_image(contents: bytes, content_type: str = "image/jpeg"):
     image = Image.open(io.BytesIO(contents)).convert("RGB")
 
-    # all 3 run in parallel
-    score1, score2, score3 = await asyncio.gather(
-        call_model(CLOUD_MODEL_1, contents, "Ateeqq", content_type),
-        call_model(CLOUD_MODEL_2, contents, "prithivMLmods", content_type),
-        call_groq_vision(contents)
-    )
-
-    scores = [(s, n) for s, n in [
-        (score1, "Ateeqq"),
-        (score2, "prithivMLmods"),
-        (score3, "Groq_Llama4")
-    ] if s is not None]
-
-    if scores:
-        combined_model_score = sum(s for s, _ in scores) / len(scores)
-        models_used = [n for _, n in scores]
-    else:
-        combined_model_score = 0.5
-        models_used = []
+    score = await call_groq_vision(contents)
+
+    combined_model_score = score if score is not None else 0.5
+    models_used = ["Groq_Llama4"] if score is not None else []
 
     metadata_risk = calculate_metadata_risk(image)
     authenticity, fake = fusion_score(combined_model_score, metadata_risk)
 
-    # confidence level
     diff = abs(authenticity - fake)
-    if diff < 20:
-        confidence_level = "low"
-    elif diff < 40:
-        confidence_level = "medium"
-    else:
-        confidence_level = "high"
+    confidence_level = "low" if diff < 20 else "medium" if diff < 40 else "high"
 
     return {
         "type": "image",
@@ -227,9 +155,7 @@ async def analyze_image(contents: bytes, content_type: str = "image/jpeg"):
         "confidence_level": confidence_level,
         "models_used": models_used,
         "details": {
-            "model1_score": round(score1, 4) if score1 is not None else "unavailable",
-            "model2_score": round(score2, 4) if score2 is not None else "unavailable",
-            "groq_score": round(score3, 4) if score3 is not None else "unavailable",
+            "groq_score": round(score, 4) if score is not None else "unavailable",
             "metadata_risk": round(metadata_risk, 4),
         }
     }
@@ -243,8 +169,6 @@ def analyze_video(contents: bytes):
         "confidence_level": "low",
         "models_used": ["placeholder"],
         "details": {
-            "model1_score": "unavailable",
-            "model2_score": "unavailable",
             "groq_score": "unavailable",
             "metadata_risk": 0.1,
         }