update classification

app.py

@@ -6,11 +6,10 @@ from flask_cors import CORS
 # =============================================================
 # ✅ Environment Configuration
 # =============================================================
-# Hugging Face allows writes only under /tmp, so create safe dirs
 os.environ["MODEL_DIR"] = "/tmp/model"
 os.environ["MPLCONFIGDIR"] = "/tmp/matplotlib"
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"   # Suppress TensorFlow INFO/WARN
-os.environ["GLOG_minloglevel"] = "2"       # Suppress Mediapipe logs
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+os.environ["GLOG_minloglevel"] = "2"
 
 os.makedirs(os.environ["MODEL_DIR"], exist_ok=True)
 os.makedirs(os.environ["MPLCONFIGDIR"], exist_ok=True)
@@ -20,45 +19,29 @@ os.makedirs(os.environ["MPLCONFIGDIR"], exist_ok=True)
 # =============================================================
 app = Flask(__name__)
 
-# CORS Configuration
 CORS(
     app,
-    resources={
-        r"/api/*": {
-            "origins": [
-                "http://localhost:3000",
-                "http://127.0.0.1:3000",
-                "https://proctorvision-client.vercel.app",
-                "https://proctorvision-server-production.up.railway.app",
-            ]
-        }
-    },
+    resources={r"/api/*": {
+        "origins": [
+            "http://localhost:3000",
+            "http://127.0.0.1:3000",
+            "https://proctorvision-client.vercel.app",
+            "https://proctorvision-server-production.up.railway.app",
+        ]
+    }},
     supports_credentials=True,
 )
 
 # =============================================================
-# 🔍 Import Blueprints (with deep diagnostics)
+# 🔍 Import Blueprint (Classification only)
 # =============================================================
 try:
-    print("🔍 Attempting to import blueprints...")
+    print("🔍 Attempting to import classification routes...")
 
     from routes.classification_routes import classification_bp
-    # from routes.webrtc_routes import webrtc_bp
-
-    print("✅ Successfully imported classification_bp from routes.classification_routes")
-
-    # Inspect blueprint details
-    if hasattr(classification_bp, "url_prefix"):
-        print(f"📦 Blueprint prefix: {getattr(classification_bp, 'url_prefix', 'None')}")
-    if hasattr(classification_bp, "deferred_functions"):
-        print(f"📋 Blueprint has {len(classification_bp.deferred_functions)} deferred functions")
-
-    # Register the blueprints
     app.register_blueprint(classification_bp, url_prefix="/api")
-    print("✅ classification_bp registered successfully.")
 
-    # app.register_blueprint(webrtc_bp)
-    # print("✅ webrtc_bp registered successfully.")
+    print("✅ classification_bp registered successfully.")
 
 except Exception as e:
     print("⚠️ Failed to import or register blueprints.")
@@ -68,21 +51,21 @@ except Exception as e:
     traceback.print_exc()
 
 # =============================================================
-# 🔎 Debug: Log All Registered Routes
+# 🔎 Debug: List Registered Routes
 # =============================================================
 print("\n🔍 Final Registered Routes:")
 for rule in app.url_map.iter_rules():
     print(f"➡ {rule.endpoint} → {rule}")
 
 # =============================================================
-# 🌐 Root & Health Check Route
+# 🌐 Root Route
 # =============================================================
 @app.route("/")
 def home():
     routes = [str(rule) for rule in app.url_map.iter_rules()]
     return jsonify({
         "status": "ok",
-        "message": "✅ ProctorVision AI Backend Running",
+        "message": "✅ ProctorVision AI Classification Backend Running",
         "available_routes": routes
     })
 
@@ -90,8 +73,7 @@ def home():
 # 🚀 Main Entrypoint
 # =============================================================
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))  # Default for Hugging Face
+    port = int(os.environ.get("PORT", 7860))
     debug = os.environ.get("DEBUG", "False").lower() == "true"
-
     print(f"\n🚀 Starting Flask server on port {port} (debug={debug})...")
     app.run(host="0.0.0.0", port=port, debug=debug)

requirements.txt

@@ -1,9 +1,7 @@
 Flask==3.0.3
 Flask-Cors==4.0.0
 numpy==1.26.4
-opencv-python-headless==4.9.0.80
-mediapipe==0.10.14
 Pillow==10.3.0
 tensorflow-cpu==2.15.0
+requests==2.31.0
 gunicorn==21.2.0
-aiortc==1.9.0

routes/classification_routes.py

@@ -1,9 +1,9 @@
 import os, io, base64, requests
 from pathlib import Path
 from flask import Blueprint, request, jsonify
-import tensorflow as tf
 import numpy as np
 from PIL import Image
+import tensorflow as tf
 
 try:
     from tensorflow.keras.applications import mobilenet_v2 as _mv2
@@ -11,13 +11,13 @@ except Exception:
     from keras.applications import mobilenet_v2 as _mv2
 
 preprocess_input = _mv2.preprocess_input
-classification_bp = Blueprint('classification_bp', __name__)
+classification_bp = Blueprint("classification_bp", __name__)
 
-# ------------------------------------------------------------
-# Model setup and auto-download
-# ------------------------------------------------------------
+# =============================================================
+# 🧠 Model Setup
+# =============================================================
 MODEL_DIR = Path(os.getenv("MODEL_DIR", "/tmp/model"))
-os.makedirs(MODEL_DIR, exist_ok=True)
+MODEL_DIR.mkdir(parents=True, exist_ok=True)
 
 MODEL_URLS = {
     "model": "https://huggingface.co/Gwen01/ProctorVision-Models/resolve/main/cheating_mobilenetv2_final.keras",
@@ -36,80 +36,67 @@ for key, url in MODEL_URLS.items():
             f.write(r.content)
         print(f"✅ Saved {key} → {local_path}")
 
-# Candidate filenames for compatibility
 CANDIDATES = [
     "cheating_mobilenetv2_final.keras",
-    "mnv2_clean_best.keras",
-    "mnv2_continue.keras",
-    "mnv2_finetune_best.keras",
+    "cheating_mobilenetv2_final.h5",
 ]
 
-
 model_path = next((MODEL_DIR / f for f in CANDIDATES if (MODEL_DIR / f).exists()), None)
+
+model = None
 if model_path and model_path.exists():
-    model = tf.keras.models.load_model(model_path, compile=False)
-    print(f"✅ Model loaded: {model_path}")
+    try:
+        model = tf.keras.models.load_model(model_path, compile=False)
+        print(f"✅ Model loaded successfully from {model_path}")
+    except Exception as e:
+        print(f"❌ Failed to load model: {e}")
 else:
-    model = None
-    print(f"⚠️ No model found in {MODEL_DIR}. Put one of: {CANDIDATES}")
+    print(f"⚠️ No valid model found in {MODEL_DIR}")
 
 # --- Load threshold ---
 thr_file = MODEL_DIR / "best_threshold.npy"
 THRESHOLD = float(np.load(thr_file)[0]) if thr_file.exists() else 0.555
 print(f"📊 Using decision threshold: {THRESHOLD:.3f}")
 
-# --- Input shape ---
+# --- Default Input Shape ---
 if model is not None:
     H, W = model.input_shape[1:3]
 else:
-    H, W = 224, 224  # fallback
+    H, W = 224, 224
 
 LABELS = ["Cheating", "Not Cheating"]
 
-# ------------------------------------------------------------
-# Helper Functions
-# ------------------------------------------------------------
+# =============================================================
+# 🧩 Helper Functions
+# =============================================================
 def preprocess_pil(pil_img: Image.Image) -> np.ndarray:
-    img = pil_img.convert("RGB")
-    if img.size != (W, H):
-        img = img.resize((W, H), Image.BILINEAR)
+    img = pil_img.convert("RGB").resize((W, H))
     x = np.asarray(img, dtype=np.float32)
     x = preprocess_input(x)
     return np.expand_dims(x, 0)
 
 def predict_batch(batch_np: np.ndarray) -> np.ndarray:
-    probs = model.predict(batch_np, verbose=0).ravel()
-    if probs.ndim == 0:
-        probs = np.array([probs])
-    if len(probs) != batch_np.shape[0]:
-        raw = model.predict(batch_np, verbose=0)
-        if raw.ndim == 2 and raw.shape[1] == 2:
-            probs = raw[:, 1]  # probability of "Not Cheating"
-        else:
-            probs = raw.ravel()
+    raw = model.predict(batch_np, verbose=0)
+    if raw.ndim == 2 and raw.shape[1] == 2:
+        probs = raw[:, 1]  # Probability of "Not Cheating"
+    else:
+        probs = raw.ravel()
     return probs
 
 def label_from_prob(prob_non_cheating: float) -> str:
     return LABELS[int(prob_non_cheating >= THRESHOLD)]
 
-# ------------------------------------------------------------
-# Environment Variables
-# ------------------------------------------------------------
-RAILWAY_API = os.getenv("RAILWAY_API", "").rstrip("/")
-if not RAILWAY_API:
-    print("⚠️ WARNING: RAILWAY_API not set — backend sync will fail.")
-
-# ------------------------------------------------------------
-# Route 1 — Classify uploaded multiple files (manual)
-# ------------------------------------------------------------
-@classification_bp.route('/classify_multiple', methods=['POST'])
+# =============================================================
+# 🔹 Route 1 — Classify Multiple Uploaded Files
+# =============================================================
+@classification_bp.route("/classify_multiple", methods=["POST"])
 def classify_multiple():
     if model is None:
         return jsonify({"error": "Model not loaded."}), 500
 
-    files = request.files.getlist('files') if 'files' in request.files else []
+    files = request.files.getlist("files")
     if not files:
-        return jsonify({"error": "No files uploaded"}), 400
+        return jsonify({"error": "No files uploaded."}), 400
 
     batch = []
     for f in files:
@@ -117,9 +104,9 @@ def classify_multiple():
             pil = Image.open(io.BytesIO(f.read()))
             batch.append(preprocess_pil(pil)[0])
         except Exception as e:
-            return jsonify({"error": f"Error reading image: {str(e)}"}), 400
+            return jsonify({"error": f"Error reading image: {e}"}), 400
 
-    batch_np = np.stack(batch, axis=0)
+    batch_np = np.stack(batch)
     probs = predict_batch(batch_np)
     labels = [label_from_prob(p) for p in probs]
 
@@ -128,68 +115,53 @@ def classify_multiple():
         "results": [{"label": lbl, "prob_non_cheating": float(p)} for lbl, p in zip(labels, probs)]
     })
 
-# ------------------------------------------------------------
-# Route 2 — Auto-classify Behavior Logs (Backend-to-Backend)
-# ------------------------------------------------------------
-@classification_bp.route('/classify_behavior_logs', methods=['POST'])
+# =============================================================
+# 🔹 Route 2 — Classify Behavior Logs (Backend-to-Backend)
+# =============================================================
+@classification_bp.route("/classify_behavior_logs", methods=["POST"])
 def classify_behavior_logs():
     if model is None:
         return jsonify({"error": "Model not loaded."}), 500
 
     data = request.get_json(silent=True) or {}
-    user_id = data.get('user_id')
-    exam_id = data.get('exam_id')
+    user_id = data.get("user_id")
+    exam_id = data.get("exam_id")
     if not user_id or not exam_id:
         return jsonify({"error": "Missing user_id or exam_id"}), 400
 
-    # --- Fetch behavior logs from Railway ---
+    RAILWAY_API = os.getenv("RAILWAY_API", "").rstrip("/")
+    if not RAILWAY_API:
+        return jsonify({"error": "RAILWAY_API not configured."}), 500
+
+    # Fetch logs
     try:
         fetch_url = f"{RAILWAY_API}/api/fetch_behavior_logs"
-        response = requests.get(fetch_url, params={"user_id": user_id, "exam_id": exam_id})
-        if response.status_code != 200:
-            return jsonify({"error": f"Failed to fetch logs: {response.text}"}), 500
-
-        logs = response.json().get("logs", [])
+        res = requests.get(fetch_url, params={"user_id": user_id, "exam_id": exam_id})
+        res.raise_for_status()
+        logs = res.json().get("logs", [])
         if not logs:
             return jsonify({"message": "No logs to classify."}), 200
     except Exception as e:
-        return jsonify({"error": f"Failed to reach Railway API: {str(e)}"}), 500
+        return jsonify({"error": f"Failed to fetch logs: {e}"}), 500
 
-    # --- Process & Predict ---
     updates = []
-    CHUNK = 64
-    for i in range(0, len(logs), CHUNK):
-        chunk = logs[i:i+CHUNK]
-        batch = []
-        ids = []
-
-        for log in chunk:
-            try:
-                img_data = base64.b64decode(log["image_base64"])
-                pil = Image.open(io.BytesIO(img_data))
-                batch.append(preprocess_pil(pil)[0])
-                ids.append(log["id"])
-            except Exception as e:
-                print(f"⚠️ Failed to read image ID {log['id']}: {e}")
-
-        if not batch:
-            continue
-
-        batch_np = np.stack(batch, axis=0)
-        probs = predict_batch(batch_np)
-        labels = [label_from_prob(p) for p in probs]
-
-        for log_id, lbl in zip(ids, labels):
-            updates.append({"id": log_id, "label": lbl})
-
-    # --- Send predictions back to Railway ---
+    for log in logs:
+        try:
+            img_data = base64.b64decode(log["image_base64"])
+            pil = Image.open(io.BytesIO(img_data))
+            batch = preprocess_pil(pil)
+            prob = predict_batch(batch)[0]
+            lbl = label_from_prob(prob)
+            updates.append({"id": log["id"], "label": lbl})
+        except Exception as e:
+            print(f"⚠️ Skipped log {log.get('id')}: {e}")
+
     try:
         update_url = f"{RAILWAY_API}/api/update_classifications"
         post_res = requests.post(update_url, json={"updates": updates})
-        if post_res.status_code != 200:
-            return jsonify({"error": f"Failed to update classifications: {post_res.text}"}), 500
+        post_res.raise_for_status()
     except Exception as e:
-        return jsonify({"error": f"Failed to push updates: {str(e)}"}), 500
+        return jsonify({"error": f"Failed to push updates: {e}"}), 500
 
     return jsonify({
         "message": f"Classification complete for {len(updates)} logs.",

routes/webrtc_routes.py

@@ -1,309 +0,0 @@
-import asyncio, time, traceback, os, threading, base64, cv2, numpy as np, mediapipe as mp, requests
-from collections import defaultdict, deque
-from aiortc import RTCPeerConnection, RTCSessionDescription
-from aiortc.contrib.media import MediaBlackhole
-from flask import Blueprint, request, jsonify
-
-# ----------------------------------------------------------------------
-# CONFIGURATION
-# ----------------------------------------------------------------------
-webrtc_bp = Blueprint("webrtc", __name__)
-
-# Base URL of your main (Railway) backend
-RAILWAY_API = os.getenv("RAILWAY_API", "").rstrip("/")
-if not RAILWAY_API:
-    print("⚠️ WARNING: RAILWAY_API not set — backend communication may fail.")
-
-SUMMARY_EVERY_S = float(os.getenv("PROCTOR_SUMMARY_EVERY_S", "1.0"))
-RECV_TIMEOUT_S  = float(os.getenv("PROCTOR_RECV_TIMEOUT_S", "5.0"))
-HEARTBEAT_S     = float(os.getenv("PROCTOR_HEARTBEAT_S", "10.0"))
-
-# ----------------------------------------------------------------------
-# LOGGING UTIL
-# ----------------------------------------------------------------------
-def log(event, sid="-", eid="-", **kv):
-    tail = " ".join(f"{k}={v}" for k, v in kv.items())
-    print(f"[{event}] sid={sid} eid={eid} {tail}".strip(), flush=True)
-
-# ----------------------------------------------------------------------
-# HELPER: send background POST to Railway backend
-# ----------------------------------------------------------------------
-def _send_to_railway(endpoint, payload, sid, eid):
-    """Send POST requests asynchronously to Railway backend."""
-    def _worker():
-        try:
-            url = f"{RAILWAY_API}{endpoint}"
-            r = requests.post(url, json=payload, timeout=10)
-            if r.status_code != 200:
-                log("RAILWAY_POST_FAIL", sid, eid, code=r.status_code, msg=r.text)
-        except Exception as e:
-            log("RAILWAY_POST_ERR", sid, eid, err=str(e))
-    threading.Thread(target=_worker, daemon=True).start()
-
-# ----------------------------------------------------------------------
-# GLOBAL STATE
-# ----------------------------------------------------------------------
-_loop = asyncio.new_event_loop()
-threading.Thread(target=_loop.run_forever, daemon=True).start()
-pcs = set()
-last_warning = defaultdict(lambda: {"warning": "Looking Forward", "at": 0})
-last_capture = defaultdict(lambda: {"label": None, "at": 0})
-last_metrics = defaultdict(lambda: {"yaw": None, "pitch": None, "dx": None, "dy": None,
-                                    "fps": None, "label": "n/a", "at": 0})
-
-# ----------------------------------------------------------------------
-# MEDIAPIPE SETUP
-# ----------------------------------------------------------------------
-mp_face_mesh = mp.solutions.face_mesh
-mp_hands = mp.solutions.hands
-
-face_mesh = mp_face_mesh.FaceMesh(
-    static_image_mode=False, max_num_faces=1, refine_landmarks=True,
-    min_detection_confidence=0.5, min_tracking_confidence=0.5  # relaxed threshold
-)
-hands = mp_hands.Hands(
-    static_image_mode=False, max_num_hands=2,
-    min_detection_confidence=0.5, min_tracking_confidence=0.5
-)
-
-# ----------------------------------------------------------------------
-# DETECTOR CLASS
-# ----------------------------------------------------------------------
-IDX_NOSE, IDX_CHIN, IDX_LE, IDX_RE, IDX_LM, IDX_RM = 1, 152, 263, 33, 291, 61
-MODEL_3D = np.array([
-    [0.0,   0.0,   0.0],
-    [0.0, -63.6, -12.5],
-    [-43.3, 32.7, -26.0],
-    [43.3,  32.7, -26.0],
-    [-28.9, -28.9, -24.1],
-    [28.9,  -28.9, -24.1],
-], dtype=np.float32)
-
-def _landmarks_to_pts(lms, w, h):
-    ids = [IDX_NOSE, IDX_CHIN, IDX_LE, IDX_RE, IDX_LM, IDX_RM]
-    return np.array([[lms[i].x * w, lms[i].y * h] for i in ids], dtype=np.float32)
-
-def _bbox_from_landmarks(lms, w, h, pad=0.03):
-    xs = [p.x for p in lms]; ys = [p.y for p in lms]
-    x1n, y1n = max(0.0, min(xs) - pad), max(0.0, min(ys) - pad)
-    x2n, y2n = min(1.0, max(xs) + pad), min(1.0, max(ys) + pad)
-    return (int(x1n*w), int(y1n*h), int(x2n*w), int(y2n*h))
-
-# Tuned thresholds
-YAW_DEG_TRIG, PITCH_UP, PITCH_DOWN = 6, 7, 11
-SMOOTH_N, CAPTURE_MIN_MS = 5, 1200
-
-class ProctorDetector:
-    def __init__(self):
-        self.yaw_hist, self.pitch_hist = deque(maxlen=SMOOTH_N), deque(maxlen=SMOOTH_N)
-        self.last_capture_ms, self.noface_streak, self.hand_streak = 0, 0, 0
-        self.last_print = 0.0
-
-    def _pose_angles(self, lms, w, h):
-        try:
-            pts2d = _landmarks_to_pts(lms, w, h)
-            cam = np.array([[w, 0, w/2], [0, h, h/2], [0, 0, 1]], dtype=np.float32)
-            ok, rvec, _ = cv2.solvePnP(MODEL_3D, pts2d, cam, np.zeros((4,1)))
-            if not ok: return None, None
-            R, _ = cv2.Rodrigues(rvec)
-            _, _, euler = cv2.RQDecomp3x3(R)
-            pitch, yaw, _ = map(float, euler)
-            return yaw, pitch
-        except Exception as e:
-            log("POSE_ERR", err=str(e))
-            return None, None
-
-    def detect(self, bgr, sid="-", eid="-"):
-        try:
-            h, w = bgr.shape[:2]
-            rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
-            rgb = cv2.flip(rgb, 1)  # ✅ flip horizontally for mirrored webcam
-            res = face_mesh.process(rgb)
-
-            if not res.multi_face_landmarks:
-                self.noface_streak += 1
-                log("NO_FACE_FRAME", sid, eid, streak=self.noface_streak)
-                return "No Face", None, rgb
-
-            self.noface_streak = 0
-            lms = res.multi_face_landmarks[0].landmark
-            yaw, pitch = self._pose_angles(lms, w, h)
-            label = "Looking Forward"
-
-            if yaw is not None and pitch is not None:
-                if abs(yaw) > YAW_DEG_TRIG:
-                    label = "Looking Left" if yaw < 0 else "Looking Right"
-                elif pitch > PITCH_DOWN:
-                    label = "Looking Down"
-                elif pitch < -PITCH_UP:
-                    label = "Looking Up"
-                else:
-                    label = "Looking Forward"
-
-            # Detailed angles log
-            if time.time() - self.last_print > 1.5:
-                log("ANGLES", sid, eid, yaw=round(yaw or 0, 2), pitch=round(pitch or 0, 2), label=label)
-                self.last_print = time.time()
-
-            log("FACE_DETECTED", sid, eid, label=label)
-            return label, _bbox_from_landmarks(lms, w, h), rgb
-
-        except Exception as e:
-            log("DETECT_EXCEPTION", sid, eid, err=str(e))
-            traceback.print_exc()
-            return "Error", None, bgr
-
-    def detect_hands_anywhere(self, rgb, sid="-", eid="-"):
-        try:
-            res = hands.process(rgb)
-            if not res.multi_hand_landmarks:
-                self.hand_streak = 0
-                return None
-            self.hand_streak += 1
-            log("HAND_DETECTED", sid, eid, count=len(res.multi_hand_landmarks))
-            return "Hand Detected"
-        except Exception as e:
-            log("HAND_ERR", sid, eid, err=str(e))
-            return None
-
-    def _throttle_ok(self):
-        return int(time.time()*1000) - self.last_capture_ms >= CAPTURE_MIN_MS
-    def _mark_captured(self): self.last_capture_ms = int(time.time()*1000)
-
-detectors = defaultdict(ProctorDetector)
-
-# ----------------------------------------------------------------------
-# CAPTURE HANDLER — SENDS TO RAILWAY
-# ----------------------------------------------------------------------
-def _maybe_capture(student_id: str, exam_id: str, bgr, label: str):
-    try:
-        ok, buf = cv2.imencode(".jpg", bgr)
-        if not ok:
-            log("CAPTURE_SKIP", student_id, exam_id, reason="encode_failed")
-            return
-
-        img_b64 = base64.b64encode(buf).decode("utf-8")
-        log("CAPTURE_TRIGGERED", student_id, exam_id, label=label, bytes=len(buf))
-
-        _send_to_railway("/api/save_behavior_log", {
-            "user_id": int(student_id),
-            "exam_id": int(exam_id),
-            "image_base64": img_b64,
-            "warning_type": label
-        }, student_id, exam_id)
-
-        _send_to_railway("/api/increment_suspicious", {
-            "student_id": int(student_id)
-        }, student_id, exam_id)
-
-        ts = int(time.time() * 1000)
-        last_capture[(student_id, exam_id)] = {"label": label, "at": ts}
-        log("LAST_CAPTURE_SET", student_id, exam_id, label=label, at=ts)
-    except Exception as e:
-        log("CAPTURE_ERR", student_id, exam_id, err=str(e))
-        traceback.print_exc()
-
-# ----------------------------------------------------------------------
-# WEBRTC OFFER HANDLER
-# ----------------------------------------------------------------------
-async def _wait_ice_complete(pc):
-    if pc.iceGatheringState == "complete": return
-    done = asyncio.Event()
-    @pc.on("icegatheringstatechange")
-    def _(_ev=None):
-        if pc.iceGatheringState == "complete": done.set()
-    await asyncio.wait_for(done.wait(), timeout=5.0)
-
-async def handle_offer(data):
-    sid, eid = str(data.get("student_id", "0")), str(data.get("exam_id", "0"))
-    log("OFFER_HANDLE", sid, eid)
-    offer = RTCSessionDescription(sdp=data["sdp"], type=data["type"])
-    pc = RTCPeerConnection()
-    pcs.add(pc)
-
-    @pc.on("connectionstatechange")
-    async def _():
-        log("CONN_STATE", sid, eid, state=pc.connectionState)
-        if pc.connectionState in ("failed", "closed", "disconnected"):
-            await pc.close()
-            pcs.discard(pc)
-            for d in (detectors, last_warning, last_metrics, last_capture):
-                d.pop((sid, eid), None)
-            log("PC_CLOSED", sid, eid)
-
-    @pc.on("track")
-    def on_track(track):
-        log("TRACK", sid, eid, kind=track.kind)
-        if track.kind != "video":
-            MediaBlackhole().addTrack(track)
-            return
-        async def reader():
-            det = detectors[(sid, eid)]
-            while True:
-                try:
-                    frame = await asyncio.wait_for(track.recv(), timeout=RECV_TIMEOUT_S)
-                    log("FRAME_RECV", sid, eid)
-                except asyncio.TimeoutError:
-                    continue
-                except Exception as e:
-                    log("TRACK_RECV_ERR", sid, eid, err=str(e))
-                    traceback.print_exc()
-                    break
-                try:
-                    bgr = frame.to_ndarray(format="bgr24")
-                    head_label, _, rgb = det.detect(bgr, sid, eid)
-                    hand_label = det.detect_hands_anywhere(rgb, sid, eid)
-                    warn = hand_label or head_label
-                    ts = int(time.time() * 1000)
-                    last_warning[(sid, eid)] = {"warning": warn, "at": ts}
-                    log("DETECTION_RESULT", sid, eid, warn=warn)
-                    if det._throttle_ok() and warn not in ("Looking Forward", None, "No Face"):
-                        _maybe_capture(sid, eid, bgr, warn)
-                        det._mark_captured()
-                except Exception as e:
-                    log("DETECT_ERR", sid, eid, err=str(e))
-                    traceback.print_exc()
-                    continue
-        asyncio.ensure_future(reader(), loop=_loop)
-
-    await pc.setRemoteDescription(offer)
-    answer = await pc.createAnswer()
-    await pc.setLocalDescription(answer)
-    await _wait_ice_complete(pc)
-    return pc.localDescription
-
-# ----------------------------------------------------------------------
-# ROUTES
-# ----------------------------------------------------------------------
-@webrtc_bp.route("/webrtc/offer", methods=["POST"])
-def webrtc_offer():
-    try:
-        data = request.get_json(force=True)
-        desc = asyncio.run_coroutine_threadsafe(handle_offer(data), _loop).result()
-        return jsonify({"sdp": desc.sdp, "type": desc.type})
-    except Exception as e:
-        traceback.print_exc()
-        return jsonify({"error": str(e)}), 500
-
-@webrtc_bp.route("/webrtc/cleanup", methods=["POST"])
-def webrtc_cleanup():
-    async def _close_all():
-        for pc in list(pcs):
-            await pc.close()
-            pcs.discard(pc)
-    asyncio.run_coroutine_threadsafe(_close_all(), _loop)
-    return jsonify({"ok": True})
-
-@webrtc_bp.route("/proctor/last_warning")
-def proctor_last_warning():
-    sid, eid = request.args.get("student_id"), request.args.get("exam_id")
-    if not sid or not eid:
-        return jsonify(error="missing student_id or exam_id"), 400
-    return jsonify(last_warning.get((sid, eid), {"warning": "Looking Forward", "at": 0}))
-
-@webrtc_bp.route("/proctor/last_capture")
-def proctor_last_capture():
-    sid, eid = request.args.get("student_id"), request.args.get("exam_id")
-    if not sid or not eid:
-        return jsonify(error="missing student_id or exam_id"), 400
-    return jsonify(last_capture.get((sid, eid), {"label": None, "at": 0}))