Combine all updated main code together, forming new main.py

main.py

@@ -306,7 +306,13 @@ class VideoTransformTrack(VideoStreamTrack):
             channel = self.get_channel()
             if channel and channel.readyState == "open":
                 try:
-                    channel.send(json.dumps({"type": "detection", "focused": is_focused, "confidence": round(confidence, 3), "detections": detections}))
+                    channel.send(json.dumps({
+                        "type": "detection",
+                        "focused": is_focused,
+                        "confidence": round(confidence, 3),
+                        "detections": [],
+                        "model": model_name,
+                    }))
                 except Exception:
                     pass
 
@@ -707,8 +713,10 @@ async def websocket_endpoint(websocket: WebSocket):
                     "type": "detection",
                     "focused": is_focused,
                     "confidence": round(confidence, 3),
+                    "detections": [],
                     "model": model_name,
                     "fc": frame_count,
+                    "frame_count": frame_count,
                 }
                 if active_pipeline is not None:
                     # Send detailed metrics for HUD
@@ -941,9 +949,13 @@ async def health_check():
 
 # ================ STATIC FILES (SPA SUPPORT) ================
 
-# Resolve static dir from this file so it works regardless of cwd
-_STATIC_DIR = Path(__file__).resolve().parent / "static"
-_ASSETS_DIR = _STATIC_DIR / "assets"
+# Resolve frontend dir from this file so it works regardless of cwd.
+# Prefer a built `dist/` app when present, otherwise fall back to `static/`.
+_BASE_DIR = Path(__file__).resolve().parent
+_DIST_DIR = _BASE_DIR / "dist"
+_STATIC_DIR = _BASE_DIR / "static"
+_FRONTEND_DIR = _DIST_DIR if (_DIST_DIR / "index.html").is_file() else _STATIC_DIR
+_ASSETS_DIR = _FRONTEND_DIR / "assets"
 
 # 1. Mount the assets folder (JS/CSS) first so /assets/* is never caught by catch-all
 if _ASSETS_DIR.is_dir():
@@ -958,7 +970,11 @@ async def serve_react_app(full_path: str, request: Request):
     if full_path.startswith("assets") or full_path.startswith("assets/"):
         raise HTTPException(status_code=404, detail="Not Found")
 
-    index_path = _STATIC_DIR / "index.html"
+    file_path = _FRONTEND_DIR / full_path
+    if full_path and file_path.is_file():
+        return FileResponse(str(file_path))
+
+    index_path = _FRONTEND_DIR / "index.html"
     if index_path.is_file():
         return FileResponse(str(index_path))
-    return {"message": "React app not found. Please run 'npm run build' and copy dist to static."}
+    return {"message": "React app not found. Please run 'npm run build' and copy dist to static if needed."}

main_combined.py

@@ -1,980 +0,0 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional, List, Any
-import base64
-import cv2
-import numpy as np
-import aiosqlite
-import json
-from datetime import datetime, timedelta
-import math
-import os
-from pathlib import Path
-from typing import Callable
-import asyncio
-import concurrent.futures
-import threading
-
-from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
-from av import VideoFrame
-
-from mediapipe.tasks.python.vision import FaceLandmarksConnections
-from ui.pipeline import FaceMeshPipeline, MLPPipeline, HybridFocusPipeline, XGBoostPipeline
-from models.face_mesh import FaceMeshDetector
-
-# ================ FACE MESH DRAWING (server-side, for WebRTC) ================
-
-_FONT = cv2.FONT_HERSHEY_SIMPLEX
-_CYAN = (255, 255, 0)
-_GREEN = (0, 255, 0)
-_MAGENTA = (255, 0, 255)
-_ORANGE = (0, 165, 255)
-_RED = (0, 0, 255)
-_WHITE = (255, 255, 255)
-_LIGHT_GREEN = (144, 238, 144)
-
-_TESSELATION_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_TESSELATION]
-_CONTOUR_CONNS = [(c.start, c.end) for c in FaceLandmarksConnections.FACE_LANDMARKS_CONTOURS]
-_LEFT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
-_RIGHT_EYEBROW = [300, 293, 334, 296, 336, 285, 295, 282, 283, 276]
-_NOSE_BRIDGE = [6, 197, 195, 5, 4, 1, 19, 94, 2]
-_LIPS_OUTER = [61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 409, 270, 269, 267, 0, 37, 39, 40, 185, 61]
-_LIPS_INNER = [78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 191, 78]
-_LEFT_EAR_POINTS = [33, 160, 158, 133, 153, 145]
-_RIGHT_EAR_POINTS = [362, 385, 387, 263, 373, 380]
-
-
-def _lm_px(lm, idx, w, h):
-    return (int(lm[idx, 0] * w), int(lm[idx, 1] * h))
-
-
-def _draw_polyline(frame, lm, indices, w, h, color, thickness):
-    for i in range(len(indices) - 1):
-        cv2.line(frame, _lm_px(lm, indices[i], w, h), _lm_px(lm, indices[i + 1], w, h), color, thickness, cv2.LINE_AA)
-
-
-def _draw_face_mesh(frame, lm, w, h):
-    """Draw tessellation, contours, eyebrows, nose, lips, eyes, irises, gaze lines."""
-    # Tessellation (gray triangular grid, semi-transparent)
-    overlay = frame.copy()
-    for s, e in _TESSELATION_CONNS:
-        cv2.line(overlay, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), (200, 200, 200), 1, cv2.LINE_AA)
-    cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
-    # Contours
-    for s, e in _CONTOUR_CONNS:
-        cv2.line(frame, _lm_px(lm, s, w, h), _lm_px(lm, e, w, h), _CYAN, 1, cv2.LINE_AA)
-    # Eyebrows
-    _draw_polyline(frame, lm, _LEFT_EYEBROW, w, h, _LIGHT_GREEN, 2)
-    _draw_polyline(frame, lm, _RIGHT_EYEBROW, w, h, _LIGHT_GREEN, 2)
-    # Nose
-    _draw_polyline(frame, lm, _NOSE_BRIDGE, w, h, _ORANGE, 1)
-    # Lips
-    _draw_polyline(frame, lm, _LIPS_OUTER, w, h, _MAGENTA, 1)
-    _draw_polyline(frame, lm, _LIPS_INNER, w, h, (200, 0, 200), 1)
-    # Eyes
-    left_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.LEFT_EYE_INDICES], dtype=np.int32)
-    cv2.polylines(frame, [left_pts], True, _GREEN, 2, cv2.LINE_AA)
-    right_pts = np.array([_lm_px(lm, i, w, h) for i in FaceMeshDetector.RIGHT_EYE_INDICES], dtype=np.int32)
-    cv2.polylines(frame, [right_pts], True, _GREEN, 2, cv2.LINE_AA)
-    # EAR key points
-    for indices in [_LEFT_EAR_POINTS, _RIGHT_EAR_POINTS]:
-        for idx in indices:
-            cv2.circle(frame, _lm_px(lm, idx, w, h), 3, (0, 255, 255), -1, cv2.LINE_AA)
-    # Irises + gaze lines
-    for iris_idx, eye_inner, eye_outer in [
-        (FaceMeshDetector.LEFT_IRIS_INDICES, 133, 33),
-        (FaceMeshDetector.RIGHT_IRIS_INDICES, 362, 263),
-    ]:
-        iris_pts = np.array([_lm_px(lm, i, w, h) for i in iris_idx], dtype=np.int32)
-        center = iris_pts[0]
-        if len(iris_pts) >= 5:
-            radii = [np.linalg.norm(iris_pts[j] - center) for j in range(1, 5)]
-            radius = max(int(np.mean(radii)), 2)
-            cv2.circle(frame, tuple(center), radius, _MAGENTA, 2, cv2.LINE_AA)
-            cv2.circle(frame, tuple(center), 2, _WHITE, -1, cv2.LINE_AA)
-        eye_cx = int((lm[eye_inner, 0] + lm[eye_outer, 0]) / 2.0 * w)
-        eye_cy = int((lm[eye_inner, 1] + lm[eye_outer, 1]) / 2.0 * h)
-        dx, dy = center[0] - eye_cx, center[1] - eye_cy
-        cv2.line(frame, tuple(center), (int(center[0] + dx * 3), int(center[1] + dy * 3)), _RED, 1, cv2.LINE_AA)
-
-
-def _draw_hud(frame, result, model_name):
-    """Draw status bar and detail overlay matching live_demo.py."""
-    h, w = frame.shape[:2]
-    is_focused = result["is_focused"]
-    status = "FOCUSED" if is_focused else "NOT FOCUSED"
-    color = _GREEN if is_focused else _RED
-
-    # Top bar
-    cv2.rectangle(frame, (0, 0), (w, 55), (0, 0, 0), -1)
-    cv2.putText(frame, status, (10, 28), _FONT, 0.8, color, 2, cv2.LINE_AA)
-    cv2.putText(frame, model_name.upper(), (w - 150, 28), _FONT, 0.45, _WHITE, 1, cv2.LINE_AA)
-
-    # Detail line
-    conf = result.get("mlp_prob", result.get("raw_score", 0.0))
-    mar_s = f" MAR:{result['mar']:.2f}" if result.get("mar") is not None else ""
-    sf = result.get("s_face", 0)
-    se = result.get("s_eye", 0)
-    detail = f"conf:{conf:.2f} S_face:{sf:.2f} S_eye:{se:.2f}{mar_s}"
-    cv2.putText(frame, detail, (10, 48), _FONT, 0.4, _WHITE, 1, cv2.LINE_AA)
-
-    # Head pose (top right)
-    if result.get("yaw") is not None:
-        cv2.putText(frame, f"yaw:{result['yaw']:+.0f} pitch:{result['pitch']:+.0f} roll:{result['roll']:+.0f}",
-                    (w - 280, 48), _FONT, 0.4, (180, 180, 180), 1, cv2.LINE_AA)
-
-    # Yawn indicator
-    if result.get("is_yawning"):
-        cv2.putText(frame, "YAWN", (10, 75), _FONT, 0.7, _ORANGE, 2, cv2.LINE_AA)
-
-# Landmark indices used for face mesh drawing on client (union of all groups).
-# Sending only these instead of all 478 saves ~60% of the landmarks payload.
-_MESH_INDICES = sorted(set(
-    [10,338,297,332,284,251,389,356,454,323,361,288,397,365,379,378,400,377,152,148,176,149,150,136,172,58,132,93,234,127,162,21,54,103,67,109]  # face oval
-    + [33,7,163,144,145,153,154,155,133,173,157,158,159,160,161,246]  # left eye
-    + [362,382,381,380,374,373,390,249,263,466,388,387,386,385,384,398]  # right eye
-    + [468,469,470,471,472, 473,474,475,476,477]  # irises
-    + [70,63,105,66,107,55,65,52,53,46]  # left eyebrow
-    + [300,293,334,296,336,285,295,282,283,276]  # right eyebrow
-    + [6,197,195,5,4,1,19,94,2]  # nose bridge
-    + [61,146,91,181,84,17,314,405,321,375,291,409,270,269,267,0,37,39,40,185]  # lips outer
-    + [78,95,88,178,87,14,317,402,318,324,308,415,310,311,312,13,82,81,80,191]  # lips inner
-    + [33,160,158,133,153,145]  # left EAR key points
-    + [362,385,387,263,373,380]  # right EAR key points
-))
-# Build a lookup: original_index -> position in sparse array, so client can reconstruct.
-_MESH_INDEX_SET = set(_MESH_INDICES)
-
-# Initialize FastAPI app
-app = FastAPI(title="Focus Guard API")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global variables
-db_path = "focus_guard.db"
-pcs = set()
-_cached_model_name = "mlp"  # in-memory cache, updated via /api/settings
-
-async def _wait_for_ice_gathering(pc: RTCPeerConnection):
-    if pc.iceGatheringState == "complete":
-        return
-    done = asyncio.Event()
-
-    @pc.on("icegatheringstatechange")
-    def _on_state_change():
-        if pc.iceGatheringState == "complete":
-            done.set()
-
-    await done.wait()
-
-# ================ DATABASE MODELS ================
-
-async def init_database():
-    """Initialize SQLite database with required tables"""
-    async with aiosqlite.connect(db_path) as db:
-        # FocusSessions table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_sessions (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                start_time TIMESTAMP NOT NULL,
-                end_time TIMESTAMP,
-                duration_seconds INTEGER DEFAULT 0,
-                focus_score REAL DEFAULT 0.0,
-                total_frames INTEGER DEFAULT 0,
-                focused_frames INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-
-        # FocusEvents table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_events (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                session_id INTEGER NOT NULL,
-                timestamp TIMESTAMP NOT NULL,
-                is_focused BOOLEAN NOT NULL,
-                confidence REAL NOT NULL,
-                detection_data TEXT,
-                FOREIGN KEY (session_id) REFERENCES focus_sessions (id)
-            )
-        """)
-
-        # UserSettings table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS user_settings (
-                id INTEGER PRIMARY KEY CHECK (id = 1),
-                sensitivity INTEGER DEFAULT 6,
-                notification_enabled BOOLEAN DEFAULT 1,
-                notification_threshold INTEGER DEFAULT 30,
-                frame_rate INTEGER DEFAULT 30,
-                model_name TEXT DEFAULT 'mlp'
-            )
-        """)
-
-        # Insert default settings if not exists
-        await db.execute("""
-            INSERT OR IGNORE INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
-            VALUES (1, 6, 1, 30, 30, 'mlp')
-        """)
-
-        await db.commit()
-
-# ================ PYDANTIC MODELS ================
-
-class SessionCreate(BaseModel):
-    pass
-
-class SessionEnd(BaseModel):
-    session_id: int
-
-class SettingsUpdate(BaseModel):
-    sensitivity: Optional[int] = None
-    notification_enabled: Optional[bool] = None
-    notification_threshold: Optional[int] = None
-    frame_rate: Optional[int] = None
-    model_name: Optional[str] = None
-
-class VideoTransformTrack(VideoStreamTrack):
-    def __init__(self, track, session_id: int, get_channel: Callable[[], Any]):
-        super().__init__()
-        self.track = track
-        self.session_id = session_id
-        self.get_channel = get_channel
-        self.last_inference_time = 0
-        self.min_inference_interval = 1 / 60
-        self.last_frame = None
-
-    async def recv(self):
-        frame = await self.track.recv()
-        img = frame.to_ndarray(format="bgr24")
-        if img is None:
-            return frame
-
-        # Normalize size for inference/drawing
-        img = cv2.resize(img, (640, 480))
-
-        now = datetime.now().timestamp()
-        do_infer = (now - self.last_inference_time) >= self.min_inference_interval
-
-        if do_infer:
-            self.last_inference_time = now
-            
-            model_name = _cached_model_name
-            if model_name not in pipelines or pipelines.get(model_name) is None:
-                model_name = 'mlp'
-            active_pipeline = pipelines.get(model_name)
-
-            if active_pipeline is not None:
-                loop = asyncio.get_event_loop()
-                out = await loop.run_in_executor(
-                    _inference_executor,
-                    _process_frame_safe,
-                    active_pipeline,
-                    img,
-                    model_name,
-                )
-                is_focused = out["is_focused"]
-                confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
-                metadata = {"s_face": out.get("s_face", 0.0), "s_eye": out.get("s_eye", 0.0), "mar": out.get("mar", 0.0), "model": model_name}
-
-                # Draw face mesh + HUD on the video frame
-                h_f, w_f = img.shape[:2]
-                lm = out.get("landmarks")
-                if lm is not None:
-                    _draw_face_mesh(img, lm, w_f, h_f)
-                _draw_hud(img, out, model_name)
-            else:
-                is_focused = False
-                confidence = 0.0
-                metadata = {"model": model_name}
-                cv2.rectangle(img, (0, 0), (img.shape[1], 55), (0, 0, 0), -1)
-                cv2.putText(img, "NO MODEL", (10, 28), _FONT, 0.8, _RED, 2, cv2.LINE_AA)
-        
-            if self.session_id:
-                await store_focus_event(self.session_id, is_focused, confidence, metadata)
-
-            channel = self.get_channel()
-            if channel and channel.readyState == "open":
-                try:
-                    channel.send(json.dumps({
-                        "type": "detection",
-                        "focused": is_focused,
-                        "confidence": round(confidence, 3),
-                        "detections": [],
-                        "model": model_name,
-                    }))
-                except Exception:
-                    pass
-
-            self.last_frame = img
-        elif self.last_frame is not None:
-            img = self.last_frame
-
-        new_frame = VideoFrame.from_ndarray(img, format="bgr24")
-        new_frame.pts = frame.pts
-        new_frame.time_base = frame.time_base
-        return new_frame
-
-# ================ DATABASE OPERATIONS ================
-
-async def create_session():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "INSERT INTO focus_sessions (start_time) VALUES (?)",
-            (datetime.now().isoformat(),)
-        )
-        await db.commit()
-        return cursor.lastrowid
-
-async def end_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "SELECT start_time, total_frames, focused_frames FROM focus_sessions WHERE id = ?",
-            (session_id,)
-        )
-        row = await cursor.fetchone()
-
-        if not row:
-            return None
-
-        start_time_str, total_frames, focused_frames = row
-        start_time = datetime.fromisoformat(start_time_str)
-        end_time = datetime.now()
-        duration = (end_time - start_time).total_seconds()
-        focus_score = focused_frames / total_frames if total_frames > 0 else 0.0
-
-        await db.execute("""
-            UPDATE focus_sessions
-            SET end_time = ?, duration_seconds = ?, focus_score = ?
-            WHERE id = ?
-        """, (end_time.isoformat(), int(duration), focus_score, session_id))
-
-        await db.commit()
-
-        return {
-            'session_id': session_id,
-            'start_time': start_time_str,
-            'end_time': end_time.isoformat(),
-            'duration_seconds': int(duration),
-            'focus_score': round(focus_score, 3),
-            'total_frames': total_frames,
-            'focused_frames': focused_frames
-        }
-
-async def store_focus_event(session_id: int, is_focused: bool, confidence: float, metadata: dict):
-    async with aiosqlite.connect(db_path) as db:
-        await db.execute("""
-            INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
-
-        await db.execute("""
-            UPDATE focus_sessions
-            SET total_frames = total_frames + 1,
-                focused_frames = focused_frames + ?
-            WHERE id = ?
-        """, (1 if is_focused else 0, session_id))
-        await db.commit()
-
-
-class _EventBuffer:
-    """Buffer focus events in memory and flush to DB in batches to avoid per-frame DB writes."""
-
-    def __init__(self, flush_interval: float = 2.0):
-        self._buf: list = []
-        self._lock = asyncio.Lock()
-        self._flush_interval = flush_interval
-        self._task: asyncio.Task | None = None
-        self._total_frames = 0
-        self._focused_frames = 0
-
-    def start(self):
-        if self._task is None:
-            self._task = asyncio.create_task(self._flush_loop())
-
-    async def stop(self):
-        if self._task:
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
-            self._task = None
-        await self._flush()
-
-    def add(self, session_id: int, is_focused: bool, confidence: float, metadata: dict):
-        self._buf.append((session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
-        self._total_frames += 1
-        if is_focused:
-            self._focused_frames += 1
-
-    async def _flush_loop(self):
-        while True:
-            await asyncio.sleep(self._flush_interval)
-            await self._flush()
-
-    async def _flush(self):
-        async with self._lock:
-            if not self._buf:
-                return
-            batch = self._buf[:]
-            total = self._total_frames
-            focused = self._focused_frames
-            self._buf.clear()
-            self._total_frames = 0
-            self._focused_frames = 0
-
-        if not batch:
-            return
-
-        session_id = batch[0][0]
-        try:
-            async with aiosqlite.connect(db_path) as db:
-                await db.executemany("""
-                    INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
-                    VALUES (?, ?, ?, ?, ?)
-                """, batch)
-                await db.execute("""
-                    UPDATE focus_sessions
-                    SET total_frames = total_frames + ?,
-                        focused_frames = focused_frames + ?
-                    WHERE id = ?
-                """, (total, focused, session_id))
-                await db.commit()
-        except Exception as e:
-            print(f"[DB] Flush error: {e}")
-
-# ================ STARTUP/SHUTDOWN ================
-
-pipelines = {
-    "geometric": None,
-    "mlp": None,
-    "hybrid": None,
-    "xgboost": None,
-}
-
-# Thread pool for CPU-bound inference so the event loop stays responsive.
-_inference_executor = concurrent.futures.ThreadPoolExecutor(
-    max_workers=4,
-    thread_name_prefix="inference",
-)
-# One lock per pipeline so shared state (TemporalTracker, etc.) is not corrupted when
-# multiple frames are processed in parallel by the thread pool.
-_pipeline_locks = {name: threading.Lock() for name in ("geometric", "mlp", "hybrid", "xgboost")}
-
-
-def _process_frame_safe(pipeline, frame, model_name: str):
-    """Run process_frame in executor with per-pipeline lock."""
-    with _pipeline_locks[model_name]:
-        return pipeline.process_frame(frame)
-
-@app.on_event("startup")
-async def startup_event():
-    global pipelines, _cached_model_name
-    print(" Starting Focus Guard API...")
-    await init_database()
-    # Load cached model name from DB
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        if row:
-            _cached_model_name = row[0]
-    print("[OK] Database initialized")
-
-    try:
-        pipelines["geometric"] = FaceMeshPipeline()
-        print("[OK] FaceMeshPipeline (geometric) loaded")
-    except Exception as e:
-        print(f"[WARN] FaceMeshPipeline unavailable: {e}")
-
-    try:
-        pipelines["mlp"] = MLPPipeline()
-        print("[OK] MLPPipeline loaded")
-    except Exception as e:
-        print(f"[ERR] Failed to load MLPPipeline: {e}")
-
-    try:
-        pipelines["hybrid"] = HybridFocusPipeline()
-        print("[OK] HybridFocusPipeline loaded")
-    except Exception as e:
-        print(f"[WARN] HybridFocusPipeline unavailable: {e}")
-
-    try:
-        pipelines["xgboost"] = XGBoostPipeline()
-        print("[OK] XGBoostPipeline loaded")
-    except Exception as e:
-        print(f"[ERR] Failed to load XGBoostPipeline: {e}")
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    _inference_executor.shutdown(wait=False)
-    print(" Shutting down Focus Guard API...")
-
-# ================ WEBRTC SIGNALING ================
-
-@app.post("/api/webrtc/offer")
-async def webrtc_offer(offer: dict):
-    try:
-        print(f"Received WebRTC offer")
-
-        pc = RTCPeerConnection()
-        pcs.add(pc)
-
-        session_id = await create_session()
-        print(f"Created session: {session_id}")
-
-        channel_ref = {"channel": None}
-
-        @pc.on("datachannel")
-        def on_datachannel(channel):
-            print(f"Data channel opened")
-            channel_ref["channel"] = channel
-
-        @pc.on("track")
-        def on_track(track):
-            print(f"Received track: {track.kind}")
-            if track.kind == "video":
-                local_track = VideoTransformTrack(track, session_id, lambda: channel_ref["channel"])
-                pc.addTrack(local_track)
-                print(f"Video track added")
-
-            @track.on("ended")
-            async def on_ended():
-                print(f"Track ended")
-
-        @pc.on("connectionstatechange")
-        async def on_connectionstatechange():
-            print(f"Connection state changed: {pc.connectionState}")
-            if pc.connectionState in ("failed", "closed", "disconnected"):
-                try:
-                    await end_session(session_id)
-                except Exception as e:
-                    print(f"⚠Error ending session: {e}")
-                pcs.discard(pc)
-                await pc.close()
-
-        await pc.setRemoteDescription(RTCSessionDescription(sdp=offer["sdp"], type=offer["type"]))
-        print(f"Remote description set")
-
-        answer = await pc.createAnswer()
-        await pc.setLocalDescription(answer)
-        print(f"Answer created")
-
-        await _wait_for_ice_gathering(pc)
-        print(f"ICE gathering complete")
-
-        return {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type, "session_id": session_id}
-
-    except Exception as e:
-        print(f"WebRTC offer error: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"WebRTC error: {str(e)}")
-
-# ================ WEBSOCKET ================
-
-@app.websocket("/ws/video")
-async def websocket_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    session_id = None
-    frame_count = 0
-    running = True
-    event_buffer = _EventBuffer(flush_interval=2.0)
-
-    # Latest frame slot — only the most recent frame is kept, older ones are dropped.
-    # Using a dict so nested functions can mutate without nonlocal issues.
-    _slot = {"frame": None}
-    _frame_ready = asyncio.Event()
-
-    async def _receive_loop():
-        """Receive messages as fast as possible. Binary = frame, text = control."""
-        nonlocal session_id, running
-        try:
-            while running:
-                msg = await websocket.receive()
-                msg_type = msg.get("type", "")
-
-                if msg_type == "websocket.disconnect":
-                    running = False
-                    _frame_ready.set()
-                    return
-
-                # Binary message → JPEG frame (fast path, no base64)
-                raw_bytes = msg.get("bytes")
-                if raw_bytes is not None and len(raw_bytes) > 0:
-                    _slot["frame"] = raw_bytes
-                    _frame_ready.set()
-                    continue
-
-                # Text message → JSON control command (or legacy base64 frame)
-                text = msg.get("text")
-                if not text:
-                    continue
-                data = json.loads(text)
-
-                if data["type"] == "frame":
-                    # Legacy base64 path (fallback)
-                    _slot["frame"] = base64.b64decode(data["image"])
-                    _frame_ready.set()
-
-                elif data["type"] == "start_session":
-                    session_id = await create_session()
-                    event_buffer.start()
-                    for p in pipelines.values():
-                        if p is not None and hasattr(p, "reset_session"):
-                            p.reset_session()
-                    await websocket.send_json({"type": "session_started", "session_id": session_id})
-
-                elif data["type"] == "end_session":
-                    if session_id:
-                        await event_buffer.stop()
-                        summary = await end_session(session_id)
-                        if summary:
-                            await websocket.send_json({"type": "session_ended", "summary": summary})
-                        session_id = None
-        except WebSocketDisconnect:
-            running = False
-            _frame_ready.set()
-        except Exception as e:
-            print(f"[WS] receive error: {e}")
-            running = False
-            _frame_ready.set()
-
-    async def _process_loop():
-        """Process only the latest frame, dropping stale ones."""
-        nonlocal frame_count, running
-        loop = asyncio.get_event_loop()
-        while running:
-            await _frame_ready.wait()
-            _frame_ready.clear()
-            if not running:
-                return
-
-            # Grab latest frame and clear slot
-            raw = _slot["frame"]
-            _slot["frame"] = None
-            if raw is None:
-                continue
-
-            try:
-                nparr = np.frombuffer(raw, np.uint8)
-                frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-                if frame is None:
-                    continue
-                frame = cv2.resize(frame, (640, 480))
-
-                model_name = _cached_model_name
-                if model_name not in pipelines or pipelines.get(model_name) is None:
-                    model_name = "mlp"
-                active_pipeline = pipelines.get(model_name)
-
-                landmarks_list = None
-                if active_pipeline is not None:
-                    out = await loop.run_in_executor(
-                        _inference_executor,
-                        _process_frame_safe,
-                        active_pipeline,
-                        frame,
-                        model_name,
-                    )
-                    is_focused = out["is_focused"]
-                    confidence = out.get("mlp_prob", out.get("raw_score", 0.0))
-
-                    lm = out.get("landmarks")
-                    if lm is not None:
-                        # Send all 478 landmarks as flat array for tessellation drawing
-                        landmarks_list = [
-                            [round(float(lm[i, 0]), 3), round(float(lm[i, 1]), 3)]
-                            for i in range(lm.shape[0])
-                        ]
-
-                    if session_id:
-                        event_buffer.add(session_id, is_focused, confidence, {
-                            "s_face": out.get("s_face", 0.0),
-                            "s_eye": out.get("s_eye", 0.0),
-                            "mar": out.get("mar", 0.0),
-                            "model": model_name,
-                        })
-                else:
-                    is_focused = False
-                    confidence = 0.0
-
-                resp = {
-                    "type": "detection",
-                    "focused": is_focused,
-                    "confidence": round(confidence, 3),
-                    "detections": [],
-                    "model": model_name,
-                    "fc": frame_count,
-                    "frame_count": frame_count,
-                }
-                if active_pipeline is not None:
-                    # Send detailed metrics for HUD
-                    if out.get("yaw") is not None:
-                        resp["yaw"] = round(out["yaw"], 1)
-                        resp["pitch"] = round(out["pitch"], 1)
-                        resp["roll"] = round(out["roll"], 1)
-                    if out.get("mar") is not None:
-                        resp["mar"] = round(out["mar"], 3)
-                    resp["sf"] = round(out.get("s_face", 0), 3)
-                    resp["se"] = round(out.get("s_eye", 0), 3)
-                if landmarks_list is not None:
-                    resp["lm"] = landmarks_list
-                await websocket.send_json(resp)
-                frame_count += 1
-            except Exception as e:
-                print(f"[WS] process error: {e}")
-
-    try:
-        await asyncio.gather(_receive_loop(), _process_loop())
-    except Exception:
-        pass
-    finally:
-        running = False
-        if session_id:
-            await event_buffer.stop()
-            await end_session(session_id)
-
-# ================ API ENDPOINTS ================
-
-@app.post("/api/sessions/start")
-async def api_start_session():
-    session_id = await create_session()
-    return {"session_id": session_id}
-
-@app.post("/api/sessions/end")
-async def api_end_session(data: SessionEnd):
-    summary = await end_session(data.session_id)
-    if not summary: raise HTTPException(status_code=404, detail="Session not found")
-    return summary
-
-@app.get("/api/sessions")
-async def get_sessions(filter: str = "all", limit: int = 50, offset: int = 0):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-
-        # NEW: If importing/exporting all, remove limit if special flag or high limit
-        # For simplicity: if limit is -1, return all
-        limit_clause = "LIMIT ? OFFSET ?"
-        params = []
-        
-        base_query = "SELECT * FROM focus_sessions"
-        where_clause = ""
-        
-        if filter == "today":
-            date_filter = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "week":
-            date_filter = datetime.now() - timedelta(days=7)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "month":
-            date_filter = datetime.now() - timedelta(days=30)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "all":
-            # Just ensure we only get completed sessions or all sessions
-            where_clause = " WHERE end_time IS NOT NULL"
-
-        query = f"{base_query}{where_clause} ORDER BY start_time DESC"
-        
-        # Handle Limit for Exports
-        if limit == -1: 
-            # No limit clause for export
-            pass
-        else:
-            query += f" {limit_clause}"
-            params.extend([limit, offset])
-
-        cursor = await db.execute(query, tuple(params))
-        rows = await cursor.fetchall()
-        return [dict(row) for row in rows]
-
-# --- NEW: Import Endpoint ---
-@app.post("/api/import")
-async def import_sessions(sessions: List[dict]):
-    count = 0
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            for session in sessions:
-                # Use .get() to handle potential missing fields from older versions or edits
-                await db.execute("""
-                    INSERT INTO focus_sessions (start_time, end_time, duration_seconds, focus_score, total_frames, focused_frames, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    session.get('start_time'),
-                    session.get('end_time'),
-                    session.get('duration_seconds', 0),
-                    session.get('focus_score', 0.0),
-                    session.get('total_frames', 0),
-                    session.get('focused_frames', 0),
-                    session.get('created_at', session.get('start_time'))
-                ))
-                count += 1
-            await db.commit()
-        return {"status": "success", "count": count}
-    except Exception as e:
-        print(f"Import Error: {e}")
-        return {"status": "error", "message": str(e)}
-
-# --- NEW: Clear History Endpoint ---
-@app.delete("/api/history")
-async def clear_history():
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            # Delete events first (foreign key good practice)
-            await db.execute("DELETE FROM focus_events")
-            await db.execute("DELETE FROM focus_sessions")
-            await db.commit()
-        return {"status": "success", "message": "History cleared"}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.get("/api/sessions/{session_id}")
-async def get_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM focus_sessions WHERE id = ?", (session_id,))
-        row = await cursor.fetchone()
-        if not row: raise HTTPException(status_code=404, detail="Session not found")
-        session = dict(row)
-        cursor = await db.execute("SELECT * FROM focus_events WHERE session_id = ? ORDER BY timestamp", (session_id,))
-        events = [dict(r) for r in await cursor.fetchall()]
-        session['events'] = events
-        return session
-
-@app.get("/api/settings")
-async def get_settings():
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        if row: return dict(row)
-        else: return {'sensitivity': 6, 'notification_enabled': True, 'notification_threshold': 30, 'frame_rate': 30, 'model_name': 'mlp'}
-
-@app.put("/api/settings")
-async def update_settings(settings: SettingsUpdate):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT id FROM user_settings WHERE id = 1")
-        exists = await cursor.fetchone()
-        if not exists:
-            await db.execute("INSERT INTO user_settings (id, sensitivity) VALUES (1, 6)")
-            await db.commit()
-
-        updates = []
-        params = []
-        if settings.sensitivity is not None:
-            updates.append("sensitivity = ?")
-            params.append(max(1, min(10, settings.sensitivity)))
-        if settings.notification_enabled is not None:
-            updates.append("notification_enabled = ?")
-            params.append(settings.notification_enabled)
-        if settings.notification_threshold is not None:
-            updates.append("notification_threshold = ?")
-            params.append(max(5, min(300, settings.notification_threshold)))
-        if settings.frame_rate is not None:
-            updates.append("frame_rate = ?")
-            params.append(max(5, min(60, settings.frame_rate)))
-        if settings.model_name is not None and settings.model_name in pipelines and pipelines[settings.model_name] is not None:
-            updates.append("model_name = ?")
-            params.append(settings.model_name)
-            global _cached_model_name
-            _cached_model_name = settings.model_name
-
-        if updates:
-            query = f"UPDATE user_settings SET {', '.join(updates)} WHERE id = 1"
-            await db.execute(query, params)
-            await db.commit()
-        return {"status": "success", "updated": len(updates) > 0}
-
-@app.get("/api/stats/summary")
-async def get_stats_summary():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT COUNT(*) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_sessions = (await cursor.fetchone())[0]
-        cursor = await db.execute("SELECT SUM(duration_seconds) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_focus_time = (await cursor.fetchone())[0] or 0
-        cursor = await db.execute("SELECT AVG(focus_score) FROM focus_sessions WHERE end_time IS NOT NULL")
-        avg_focus_score = (await cursor.fetchone())[0] or 0.0
-        cursor = await db.execute("SELECT DISTINCT DATE(start_time) as session_date FROM focus_sessions WHERE end_time IS NOT NULL ORDER BY session_date DESC")
-        dates = [row[0] for row in await cursor.fetchall()]
-
-        streak_days = 0
-        if dates:
-            current_date = datetime.now().date()
-            for i, date_str in enumerate(dates):
-                session_date = datetime.fromisoformat(date_str).date()
-                expected_date = current_date - timedelta(days=i)
-                if session_date == expected_date: streak_days += 1
-                else: break
-        return {
-            'total_sessions': total_sessions,
-            'total_focus_time': int(total_focus_time),
-            'avg_focus_score': round(avg_focus_score, 3),
-            'streak_days': streak_days
-        }
-
-@app.get("/api/models")
-async def get_available_models():
-    """Return list of loaded model names and which is currently active."""
-    available = [name for name, p in pipelines.items() if p is not None]
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT model_name FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        current = row[0] if row else "mlp"
-        if current not in available and available:
-            current = available[0]
-    return {"available": available, "current": current}
-
-@app.get("/api/mesh-topology")
-async def get_mesh_topology():
-    """Return tessellation edge pairs for client-side face mesh drawing (cached by client)."""
-    return {"tessellation": _TESSELATION_CONNS}
-
-@app.get("/health")
-async def health_check():
-    available = [name for name, p in pipelines.items() if p is not None]
-    return {"status": "healthy", "models_loaded": available, "database": os.path.exists(db_path)}
-
-# ================ STATIC FILES (SPA SUPPORT) ================
-
-# Resolve frontend dir from this file so it works regardless of cwd.
-# Prefer a built `dist/` app when present, otherwise fall back to `static/`.
-_BASE_DIR = Path(__file__).resolve().parent
-_DIST_DIR = _BASE_DIR / "dist"
-_STATIC_DIR = _BASE_DIR / "static"
-_FRONTEND_DIR = _DIST_DIR if (_DIST_DIR / "index.html").is_file() else _STATIC_DIR
-_ASSETS_DIR = _FRONTEND_DIR / "assets"
-
-# 1. Mount the assets folder (JS/CSS) first so /assets/* is never caught by catch-all
-if _ASSETS_DIR.is_dir():
-    app.mount("/assets", StaticFiles(directory=str(_ASSETS_DIR)), name="assets")
-
-# 2. Catch-all for SPA: serve index.html for app routes, never for /assets (would break JS MIME type)
-@app.get("/{full_path:path}")
-async def serve_react_app(full_path: str, request: Request):
-    if full_path.startswith("api") or full_path.startswith("ws"):
-        raise HTTPException(status_code=404, detail="Not Found")
-    # Don't serve HTML for asset paths; let them 404 so we don't break module script loading
-    if full_path.startswith("assets") or full_path.startswith("assets/"):
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    file_path = _FRONTEND_DIR / full_path
-    if full_path and file_path.is_file():
-        return FileResponse(str(file_path))
-
-    index_path = _FRONTEND_DIR / "index.html"
-    if index_path.is_file():
-        return FileResponse(str(index_path))
-    return {"message": "React app not found. Please run 'npm run build' and copy dist to static if needed."}

main_yolo.py

@@ -1,601 +0,0 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional, List, Any
-import base64
-import cv2
-import numpy as np
-import aiosqlite
-import json
-from datetime import datetime, timedelta
-import math
-import os
-from pathlib import Path
-from typing import Callable
-import asyncio
-
-from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
-from av import VideoFrame
-
-from ui.pipeline import MLPPipeline
-
-# Initialize FastAPI app
-app = FastAPI(title="Focus Guard API")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global variables
-db_path = "focus_guard.db"
-pcs = set()
-
-async def _wait_for_ice_gathering(pc: RTCPeerConnection):
-    if pc.iceGatheringState == "complete":
-        return
-    done = asyncio.Event()
-
-    @pc.on("icegatheringstatechange")
-    def _on_state_change():
-        if pc.iceGatheringState == "complete":
-            done.set()
-
-    await done.wait()
-
-# ================ DATABASE MODELS ================
-
-async def init_database():
-    """Initialize SQLite database with required tables"""
-    async with aiosqlite.connect(db_path) as db:
-        # FocusSessions table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_sessions (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                start_time TIMESTAMP NOT NULL,
-                end_time TIMESTAMP,
-                duration_seconds INTEGER DEFAULT 0,
-                focus_score REAL DEFAULT 0.0,
-                total_frames INTEGER DEFAULT 0,
-                focused_frames INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        """)
-
-        # FocusEvents table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS focus_events (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                session_id INTEGER NOT NULL,
-                timestamp TIMESTAMP NOT NULL,
-                is_focused BOOLEAN NOT NULL,
-                confidence REAL NOT NULL,
-                detection_data TEXT,
-                FOREIGN KEY (session_id) REFERENCES focus_sessions (id)
-            )
-        """)
-
-        # UserSettings table
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS user_settings (
-                id INTEGER PRIMARY KEY CHECK (id = 1),
-                sensitivity INTEGER DEFAULT 6,
-                notification_enabled BOOLEAN DEFAULT 1,
-                notification_threshold INTEGER DEFAULT 30,
-                frame_rate INTEGER DEFAULT 30,
-                model_name TEXT DEFAULT 'yolov8n.pt'
-            )
-        """)
-
-        # Insert default settings if not exists
-        await db.execute("""
-            INSERT OR IGNORE INTO user_settings (id, sensitivity, notification_enabled, notification_threshold, frame_rate, model_name)
-            VALUES (1, 6, 1, 30, 30, 'yolov8n.pt')
-        """)
-
-        await db.commit()
-
-# ================ PYDANTIC MODELS ================
-
-class SessionCreate(BaseModel):
-    pass
-
-class SessionEnd(BaseModel):
-    session_id: int
-
-class SettingsUpdate(BaseModel):
-    sensitivity: Optional[int] = None
-    notification_enabled: Optional[bool] = None
-    notification_threshold: Optional[int] = None
-    frame_rate: Optional[int] = None
-
-class VideoTransformTrack(VideoStreamTrack):
-    def __init__(self, track, session_id: int, get_channel: Callable[[], Any]):
-        super().__init__()
-        self.track = track
-        self.session_id = session_id
-        self.get_channel = get_channel
-        self.last_inference_time = 0
-        self.min_inference_interval = 1 / 60
-        self.last_frame = None
-
-    async def recv(self):
-        frame = await self.track.recv()
-        img = frame.to_ndarray(format="bgr24")
-        if img is None:
-            return frame
-
-        # Normalize size for inference/drawing
-        img = cv2.resize(img, (640, 480))
-
-        now = datetime.now().timestamp()
-        do_infer = (now - self.last_inference_time) >= self.min_inference_interval
-
-        if do_infer and mlp_pipeline is not None:
-            self.last_inference_time = now
-            out = mlp_pipeline.process_frame(img)
-            is_focused = out["is_focused"]
-            confidence = out["mlp_prob"]
-            metadata = {"s_face": out["s_face"], "s_eye": out["s_eye"], "mar": out["mar"]}
-            detections = []
-            status_text = "FOCUSED" if is_focused else "NOT FOCUSED"
-            color = (0, 255, 0) if is_focused else (0, 0, 255)
-            cv2.putText(img, status_text, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
-            cv2.putText(img, f"Confidence: {confidence * 100:.1f}%", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
-        
-            if self.session_id:
-                await store_focus_event(self.session_id, is_focused, confidence, metadata)
-
-            channel = self.get_channel()
-            if channel and channel.readyState == "open":
-                try:
-                    channel.send(json.dumps({"type": "detection", "focused": is_focused, "confidence": round(confidence, 3), "detections": detections}))
-                except Exception:
-                    pass
-
-            self.last_frame = img
-        elif self.last_frame is not None:
-            img = self.last_frame
-
-        new_frame = VideoFrame.from_ndarray(img, format="bgr24")
-        new_frame.pts = frame.pts
-        new_frame.time_base = frame.time_base
-        return new_frame
-
-# ================ DATABASE OPERATIONS ================
-
-async def create_session():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "INSERT INTO focus_sessions (start_time) VALUES (?)",
-            (datetime.now().isoformat(),)
-        )
-        await db.commit()
-        return cursor.lastrowid
-
-async def end_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute(
-            "SELECT start_time, total_frames, focused_frames FROM focus_sessions WHERE id = ?",
-            (session_id,)
-        )
-        row = await cursor.fetchone()
-
-        if not row:
-            return None
-
-        start_time_str, total_frames, focused_frames = row
-        start_time = datetime.fromisoformat(start_time_str)
-        end_time = datetime.now()
-        duration = (end_time - start_time).total_seconds()
-        focus_score = focused_frames / total_frames if total_frames > 0 else 0.0
-
-        await db.execute("""
-            UPDATE focus_sessions
-            SET end_time = ?, duration_seconds = ?, focus_score = ?
-            WHERE id = ?
-        """, (end_time.isoformat(), int(duration), focus_score, session_id))
-
-        await db.commit()
-
-        return {
-            'session_id': session_id,
-            'start_time': start_time_str,
-            'end_time': end_time.isoformat(),
-            'duration_seconds': int(duration),
-            'focus_score': round(focus_score, 3),
-            'total_frames': total_frames,
-            'focused_frames': focused_frames
-        }
-
-async def store_focus_event(session_id: int, is_focused: bool, confidence: float, metadata: dict):
-    async with aiosqlite.connect(db_path) as db:
-        await db.execute("""
-            INSERT INTO focus_events (session_id, timestamp, is_focused, confidence, detection_data)
-            VALUES (?, ?, ?, ?, ?)
-        """, (session_id, datetime.now().isoformat(), is_focused, confidence, json.dumps(metadata)))
-
-        await db.execute(f"""
-            UPDATE focus_sessions
-            SET total_frames = total_frames + 1,
-                focused_frames = focused_frames + {1 if is_focused else 0}
-            WHERE id = ?
-        """, (session_id,))
-        await db.commit()
-
-# ================ STARTUP/SHUTDOWN ================
-
-mlp_pipeline = None
-
-@app.on_event("startup")
-async def startup_event():
-    global mlp_pipeline
-    print(" Starting Focus Guard API...")
-    await init_database()
-    print("[OK] Database initialized")
-
-    mlp_pipeline = MLPPipeline() 
-    print("[OK] MLPPipeline loaded")
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    print(" Shutting down Focus Guard API...")
-
-# ================ WEBRTC SIGNALING ================
-
-@app.post("/api/webrtc/offer")
-async def webrtc_offer(offer: dict):
-    try:
-        print(f"Received WebRTC offer")
-
-        pc = RTCPeerConnection()
-        pcs.add(pc)
-
-        session_id = await create_session()
-        print(f"Created session: {session_id}")
-
-        channel_ref = {"channel": None}
-
-        @pc.on("datachannel")
-        def on_datachannel(channel):
-            print(f"Data channel opened")
-            channel_ref["channel"] = channel
-
-        @pc.on("track")
-        def on_track(track):
-            print(f"Received track: {track.kind}")
-            if track.kind == "video":
-                local_track = VideoTransformTrack(track, session_id, lambda: channel_ref["channel"])
-                pc.addTrack(local_track)
-                print(f"Video track added")
-
-            @track.on("ended")
-            async def on_ended():
-                print(f"Track ended")
-
-        @pc.on("connectionstatechange")
-        async def on_connectionstatechange():
-            print(f"Connection state changed: {pc.connectionState}")
-            if pc.connectionState in ("failed", "closed", "disconnected"):
-                try:
-                    await end_session(session_id)
-                except Exception as e:
-                    print(f"⚠Error ending session: {e}")
-                pcs.discard(pc)
-                await pc.close()
-
-        await pc.setRemoteDescription(RTCSessionDescription(sdp=offer["sdp"], type=offer["type"]))
-        print(f"Remote description set")
-
-        answer = await pc.createAnswer()
-        await pc.setLocalDescription(answer)
-        print(f"Answer created")
-
-        await _wait_for_ice_gathering(pc)
-        print(f"ICE gathering complete")
-
-        return {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type, "session_id": session_id}
-
-    except Exception as e:
-        print(f"WebRTC offer error: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"WebRTC error: {str(e)}")
-
-# ================ WEBSOCKET ================
-
-@app.websocket("/ws/video")
-async def websocket_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    session_id = None
-    frame_count = 0
-    last_inference_time = 0
-    min_inference_interval = 1 / 60
-
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            cursor = await db.execute("SELECT sensitivity FROM user_settings WHERE id = 1")
-            row = await cursor.fetchone()
-            sensitivity = row[0] if row else 6
-
-        while True:
-            data = await websocket.receive_json()
-
-            if data['type'] == 'frame':
-                from time import time
-                current_time = time()
-                if current_time - last_inference_time < min_inference_interval:
-                    await websocket.send_json({'type': 'ack', 'frame_count': frame_count})
-                    continue
-                last_inference_time = current_time
-
-                try:
-                    img_data = base64.b64decode(data['image'])
-                    nparr = np.frombuffer(img_data, np.uint8)
-                    frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
-
-                    if frame is None: continue
-                    frame = cv2.resize(frame, (640, 480))
-
-                    if mlp_pipeline is not None:
-                        out = mlp_pipeline.process_frame(frame)
-
-                        is_focused = out["is_focused"]
-                        confidence = out["mlp_prob"]
-                        metadata = {
-                            "s_face": out["s_face"],
-                            "s_eye": out["s_eye"],
-                            "mar": out["mar"]
-                        }
-                    else:
-                        is_focused = False
-                        confidence = 0.0
-                        metadata = {}
-
-                    detections = []
-
-                    if session_id:
-                        await store_focus_event(session_id, is_focused, confidence, metadata)
-
-                    await websocket.send_json({
-                        'type': 'detection',
-                        'focused': is_focused,
-                        'confidence': round(confidence, 3),
-                        'detections': detections,
-                        'frame_count': frame_count
-                    })
-                    frame_count += 1
-                except Exception as e:
-                    print(f"Error processing frame: {e}")
-                    await websocket.send_json({'type': 'error', 'message': str(e)})
-
-            elif data['type'] == 'start_session':
-                session_id = await create_session()
-                await websocket.send_json({'type': 'session_started', 'session_id': session_id})
-
-            elif data['type'] == 'end_session':
-                if session_id:
-                    print(f"Ending session {session_id}...")
-                    summary = await end_session(session_id)
-                    print(f"Session summary: {summary}")
-                    if summary:
-                        await websocket.send_json({'type': 'session_ended', 'summary': summary})
-                        print("Session ended message sent")
-                    else:
-                        print("Warning: No summary returned")
-                    session_id = None
-                else:
-                    print("Warning: end_session called but no active session_id")
-
-    except WebSocketDisconnect:
-        if session_id: await end_session(session_id)
-    except Exception as e:
-        if websocket.client_state.value == 1: await websocket.close()
-
-# ================ API ENDPOINTS ================
-
-@app.post("/api/sessions/start")
-async def api_start_session():
-    session_id = await create_session()
-    return {"session_id": session_id}
-
-@app.post("/api/sessions/end")
-async def api_end_session(data: SessionEnd):
-    summary = await end_session(data.session_id)
-    if not summary: raise HTTPException(status_code=404, detail="Session not found")
-    return summary
-
-@app.get("/api/sessions")
-async def get_sessions(filter: str = "all", limit: int = 50, offset: int = 0):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-
-        # NEW: If importing/exporting all, remove limit if special flag or high limit
-        # For simplicity: if limit is -1, return all
-        limit_clause = "LIMIT ? OFFSET ?"
-        params = []
-        
-        base_query = "SELECT * FROM focus_sessions"
-        where_clause = ""
-        
-        if filter == "today":
-            date_filter = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "week":
-            date_filter = datetime.now() - timedelta(days=7)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "month":
-            date_filter = datetime.now() - timedelta(days=30)
-            where_clause = " WHERE start_time >= ?"
-            params.append(date_filter.isoformat())
-        elif filter == "all":
-            # Just ensure we only get completed sessions or all sessions
-            where_clause = " WHERE end_time IS NOT NULL"
-
-        query = f"{base_query}{where_clause} ORDER BY start_time DESC"
-        
-        # Handle Limit for Exports
-        if limit == -1: 
-            # No limit clause for export
-            pass
-        else:
-            query += f" {limit_clause}"
-            params.extend([limit, offset])
-
-        cursor = await db.execute(query, tuple(params))
-        rows = await cursor.fetchall()
-        return [dict(row) for row in rows]
-
-# --- NEW: Import Endpoint ---
-@app.post("/api/import")
-async def import_sessions(sessions: List[dict]):
-    count = 0
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            for session in sessions:
-                # Use .get() to handle potential missing fields from older versions or edits
-                await db.execute("""
-                    INSERT INTO focus_sessions (start_time, end_time, duration_seconds, focus_score, total_frames, focused_frames, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    session.get('start_time'),
-                    session.get('end_time'),
-                    session.get('duration_seconds', 0),
-                    session.get('focus_score', 0.0),
-                    session.get('total_frames', 0),
-                    session.get('focused_frames', 0),
-                    session.get('created_at', session.get('start_time'))
-                ))
-                count += 1
-            await db.commit()
-        return {"status": "success", "count": count}
-    except Exception as e:
-        print(f"Import Error: {e}")
-        return {"status": "error", "message": str(e)}
-
-# --- NEW: Clear History Endpoint ---
-@app.delete("/api/history")
-async def clear_history():
-    try:
-        async with aiosqlite.connect(db_path) as db:
-            # Delete events first (foreign key good practice)
-            await db.execute("DELETE FROM focus_events")
-            await db.execute("DELETE FROM focus_sessions")
-            await db.commit()
-        return {"status": "success", "message": "History cleared"}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.get("/api/sessions/{session_id}")
-async def get_session(session_id: int):
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM focus_sessions WHERE id = ?", (session_id,))
-        row = await cursor.fetchone()
-        if not row: raise HTTPException(status_code=404, detail="Session not found")
-        session = dict(row)
-        cursor = await db.execute("SELECT * FROM focus_events WHERE session_id = ? ORDER BY timestamp", (session_id,))
-        events = [dict(r) for r in await cursor.fetchall()]
-        session['events'] = events
-        return session
-
-@app.get("/api/settings")
-async def get_settings():
-    async with aiosqlite.connect(db_path) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute("SELECT * FROM user_settings WHERE id = 1")
-        row = await cursor.fetchone()
-        if row: return dict(row)
-        else: return {'sensitivity': 6, 'notification_enabled': True, 'notification_threshold': 30, 'frame_rate': 30, 'model_name': 'yolov8n.pt'}
-
-@app.put("/api/settings")
-async def update_settings(settings: SettingsUpdate):
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT id FROM user_settings WHERE id = 1")
-        exists = await cursor.fetchone()
-        if not exists:
-            await db.execute("INSERT INTO user_settings (id, sensitivity) VALUES (1, 6)")
-            await db.commit()
-
-        updates = []
-        params = []
-        if settings.sensitivity is not None:
-            updates.append("sensitivity = ?")
-            params.append(max(1, min(10, settings.sensitivity)))
-        if settings.notification_enabled is not None:
-            updates.append("notification_enabled = ?")
-            params.append(settings.notification_enabled)
-        if settings.notification_threshold is not None:
-            updates.append("notification_threshold = ?")
-            params.append(max(5, min(300, settings.notification_threshold)))
-        if settings.frame_rate is not None:
-            updates.append("frame_rate = ?")
-            params.append(max(5, min(60, settings.frame_rate)))
-
-        if updates:
-            query = f"UPDATE user_settings SET {', '.join(updates)} WHERE id = 1"
-            await db.execute(query, params)
-            await db.commit()
-        return {"status": "success", "updated": len(updates) > 0}
-
-@app.get("/api/stats/summary")
-async def get_stats_summary():
-    async with aiosqlite.connect(db_path) as db:
-        cursor = await db.execute("SELECT COUNT(*) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_sessions = (await cursor.fetchone())[0]
-        cursor = await db.execute("SELECT SUM(duration_seconds) FROM focus_sessions WHERE end_time IS NOT NULL")
-        total_focus_time = (await cursor.fetchone())[0] or 0
-        cursor = await db.execute("SELECT AVG(focus_score) FROM focus_sessions WHERE end_time IS NOT NULL")
-        avg_focus_score = (await cursor.fetchone())[0] or 0.0
-        cursor = await db.execute("SELECT DISTINCT DATE(start_time) as session_date FROM focus_sessions WHERE end_time IS NOT NULL ORDER BY session_date DESC")
-        dates = [row[0] for row in await cursor.fetchall()]
-
-        streak_days = 0
-        if dates:
-            current_date = datetime.now().date()
-            for i, date_str in enumerate(dates):
-                session_date = datetime.fromisoformat(date_str).date()
-                expected_date = current_date - timedelta(days=i)
-                if session_date == expected_date: streak_days += 1
-                else: break
-        return {
-            'total_sessions': total_sessions,
-            'total_focus_time': int(total_focus_time),
-            'avg_focus_score': round(avg_focus_score, 3),
-            'streak_days': streak_days
-        }
-
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "model_loaded": mlp_pipeline is not None, "database": os.path.exists(db_path)}
-
-# ================ STATIC FILES (SPA SUPPORT) ================
-
-FRONTEND_DIR = "dist" if os.path.exists("dist/index.html") else "static"
-
-assets_path = os.path.join(FRONTEND_DIR, "assets")
-if os.path.exists(assets_path):
-    app.mount("/assets", StaticFiles(directory=assets_path), name="assets")
-
-@app.get("/{full_path:path}")
-async def serve_react_app(full_path: str, request: Request):
-    if full_path.startswith("api") or full_path.startswith("ws"):
-        raise HTTPException(status_code=404, detail="Not Found")
-    
-    file_path = os.path.join(FRONTEND_DIR, full_path)
-    if os.path.isfile(file_path):
-        return FileResponse(file_path)
-    
-    index_path = os.path.join(FRONTEND_DIR, "index.html")
-    if os.path.exists(index_path):
-        return FileResponse(index_path)
-    else:
-        return {"message": "React app not found. Please run npm run build."}