Update main.py

main.py

@@ -1,508 +1,212 @@
-# main.py
-#
-# DreamBiomeMCP – Flask server exposing HTTP "tools" over your processed JSON
-# Files expected in the same directory:
-#   - dream_entries.json
-#   - sleep_profiles.json
-#
-# Endpoints (all JSON):
-#   GET  /health
-#   GET  /dream/series
-#   POST /dream/samples
-#   POST /dream/cluster-stats
-#   GET  /sleep/profiles
-#   GET  /sleep/profile/<profile_id>
-#   POST /sleep/profile-arc
-#   POST /seed/random-dream-biome
-#
-#   NEW (LlamaIndex, backwards compatible):
-#   POST /llama/query
-#     body:  { "query": "...", "series": "jasmine1" | null, "top_k": 5 }
-#     reply: { "enabled": bool, "answer": str, "sources": [ {id, series, text}, ... ], "error": optional }
-
+import os
+import base64
 import json
-import random
-import statistics
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from flask import Flask, jsonify, request
-
-# -------------------------------------------------------------------
-# Data loading
-# -------------------------------------------------------------------
-
-BASE_DIR = Path(__file__).resolve().parent
-DREAM_FILE = BASE_DIR / "dream_entries.json"
-SLEEP_FILE = BASE_DIR / "sleep_profiles.json"
-
-def load_json(path: Path) -> Any:
-    with path.open("r", encoding="utf-8") as f:
-        return json.load(f)
-
-print(f"[DreamBiomeMCP] Loading data from {DREAM_FILE} and {SLEEP_FILE} ...")
-ALL_DREAMS: List[Dict[str, Any]] = load_json(DREAM_FILE)
-ALL_SLEEP_PROFILES: List[Dict[str, Any]] = load_json(SLEEP_FILE)
-print(f"[DreamBiomeMCP] Loaded {len(ALL_DREAMS)} dreams, {len(ALL_SLEEP_PROFILES)} sleep profiles.")
-
-# Build quick lookup index for sleep profiles by id
-SLEEP_INDEX: Dict[str, Dict[str, Any]] = {p["id"]: p for p in ALL_SLEEP_PROFILES}
-
-
-# -------------------------------------------------------------------
-# Helper functions
-# -------------------------------------------------------------------
-
-def filter_dreams(
-    source: Optional[str] = None,
-    series: Optional[str] = None,
-    min_words: Optional[int] = None,
-    max_words: Optional[int] = None,
-) -> List[Dict[str, Any]]:
-    dreams = ALL_DREAMS
-    if source:
-        dreams = [d for d in dreams if str(d.get("source")) == source]
-    if series:
-        dreams = [d for d in dreams if str(d.get("series")) == series]
-    if min_words is not None:
-        dreams = [d for d in dreams if d.get("length_words", 0) >= min_words]
-    if max_words is not None:
-        dreams = [d for d in dreams if d.get("length_words", 0) <= max_words]
-    return dreams
-
-
-def summarise_dream_cluster(dreams: List[Dict[str, Any]]) -> Dict[str, Any]:
-    if not dreams:
-        return {
-            "count": 0,
-            "avg_length_words": 0,
-            "length_words_std": 0,
-            "metrics_means": {},
-        }
+import io
+import tempfile
+import cv2
+import numpy as np
+from flask import Flask
+from flask_socketio import SocketIO, emit
+from PIL import Image
+
+# --- 2025 AI STANDARDS ---
+from google import genai
+from google.genai import types
+import azure.cognitiveservices.speech as speechsdk
 
-    lengths = [d.get("length_words", 0) for d in dreams]
-    avg_len = statistics.mean(lengths)
-    std_len = statistics.pstdev(lengths) if len(lengths) > 1 else 0.0
-
-    # Aggregate any numeric metrics if present (from Dryad)
-    numeric_keys = set()
-    for d in dreams:
-        metrics = d.get("metrics") or {}
-        for k, v in metrics.items():
-            if isinstance(v, (int, float)):
-                numeric_keys.add(k)
-
-    metrics_means: Dict[str, float] = {}
-    for key in sorted(numeric_keys):
-        vals = []
-        for d in dreams:
-            m = (d.get("metrics") or {})
-            v = m.get(key)
-            if isinstance(v, (int, float)):
-                vals.append(float(v))
-        if vals:
-            metrics_means[key] = statistics.mean(vals)
-
-    return {
-        "count": len(dreams),
-        "avg_length_words": round(avg_len, 2),
-        "length_words_std": round(std_len, 2),
-        "metrics_means": metrics_means,
-    }
-
-
-def compute_sleep_arc(profile: Dict[str, Any]) -> Dict[str, Any]:
-    """Derive a simple "arc" from the stage sequence for storytelling."""
-    stages = profile.get("stages", [])
-    if not stages:
-        return {"segments": []}
-
-    total = len(stages)
-    step = max(total // 4, 1)
-    segments = []
-    for i in range(4):
-        start = i * step
-        end = min((i + 1) * step, total)
-        if start >= end:
-            break
-        segment = stages[start:end]
-        # simple dominant stage for this quarter
-        counts: Dict[str, int] = {}
-        for s in segment:
-            counts[s] = counts.get(s, 0) + 1
-        dominant = max(counts.items(), key=lambda kv: kv[1])[0]
-        segments.append(
-            {
-                "index": i,
-                "start_epoch": start,
-                "end_epoch": end - 1,
-                "dominant_stage": dominant,
-                "counts": counts,
-            }
-        )
+app = Flask(__name__)
 
-    return {"segments": segments, "total_epochs": total}
-
-
-def pick_random_region_context() -> Dict[str, Any]:
-    # Extremely small, hard-coded region stats for now.
-    # You can expand this or swap to a JSON file later.
-    regions = [
-        {
-            "region": "Global",
-            "insomnia_prevalence": 0.16,
-            "severe_insomnia": 0.08,
-            "notes": "Global adult insomnia meta-analysis.",
-            "reference": "global_insomnia_meta_2016",
-        },
-        {
-            "region": "UK",
-            "insomnia_prevalence": 0.29,
-            "severe_insomnia": 0.06,
-            "notes": "Symptom-based estimate from large UK cohort.",
-            "reference": "uk_biobank_insomnia",
-        },
-        {
-            "region": "East Asia",
-            "insomnia_prevalence": 0.20,
-            "severe_insomnia": 0.07,
-            "notes": "Approximate pooled prevalence from regional studies.",
-            "reference": "east_asia_insomnia_review",
-        },
-    ]
-    return random.choice(regions)
-
-
-# -------------------------------------------------------------------
-# OPTIONAL: LlamaIndex RAG over dreams
-# -------------------------------------------------------------------
-
-LLAMA_ENABLED: bool = False
-LLAMA_INDEX = None
-LLAMA_INIT_ERROR: Optional[str] = None
-
-def init_llama_index() -> None:
+# CONFIG: Hugging Face runs on port 7860 internally
+# CORS: Allow '*' so your Unity APK can connect from anywhere
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet')
+
+# --- SECRETS (Load from Hugging Face Environment Variables) ---
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+AZURE_SPEECH_KEY = os.environ.get("AZURE_SPEECH_KEY")
+AZURE_SPEECH_REGION = os.environ.get("AZURE_SPEECH_REGION")
+
+# Initialize Gemini Client
+client = genai.Client(api_key=GEMINI_API_KEY)
+
+# --- HELPER: Base64 to PIL Image ---
+def decode_image(base64_string):
+    img_bytes = base64.b64decode(base64_string)
+    np_arr = np.frombuffer(img_bytes, np.uint8)
+    frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+    return Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+
+# ==========================================
+# 1. VISUAL RECOGNITION (Wand/Pen)
+# ==========================================
+@socketio.on('verify_object')
+def handle_object_verification(data):
     """
-    Build a lightweight in-memory LlamaIndex over ALL_DREAMS.
-    Retrieval-only (no LLM generation) so we don't need extra keys.
+    Called by Unity (either as fallback or primary).
+    Payload: { 'image': 'base64...', 'target': 'pen' }
     """
-    global LLAMA_ENABLED, LLAMA_INDEX, LLAMA_INIT_ERROR
+    target = data.get('target', 'magic wand')
+    print(f"👁️ Vision Check: Looking for {target}")
 
-    print("[LlamaIndex] Initialising dream index ...")
     try:
-        from llama_index.core import VectorStoreIndex, Document, Settings
-        from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-        # Use a small local embedding model (downloads once on first run).
-        embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        Settings.embed_model = embed_model
-        Settings.llm = None  # retrieval-only; no built-in LLM
-
-        docs = []
-        for d in ALL_DREAMS:
-            text = d.get("text") or d.get("dream") or ""
-            if not text:
-                continue
-            metadata = {
-                "id": d.get("id"),
-                "series": str(d.get("series") or ""),
-                "source": str(d.get("source") or ""),
-            }
-            docs.append(Document(text=text, metadata=metadata))
-
-        if not docs:
-            LLAMA_INIT_ERROR = "No dream texts found to index."
-            print("[LlamaIndex][WARN]", LLAMA_INIT_ERROR)
-            return
-
-        LLAMA_INDEX = VectorStoreIndex.from_documents(docs)
-        LLAMA_ENABLED = True
-        LLAMA_INIT_ERROR = None
-        print(f"[LlamaIndex] Index built over {len(docs)} dreams.")
-
-    except ImportError as e:
-        LLAMA_ENABLED = False
-        LLAMA_INDEX = None
-        LLAMA_INIT_ERROR = f"ImportError: {e}"
-        print("[LlamaIndex][WARN] LlamaIndex not installed. Skipping RAG layer.")
-    except Exception as e:
-        LLAMA_ENABLED = False
-        LLAMA_INDEX = None
-        LLAMA_INIT_ERROR = f"{type(e).__name__}: {e}"
-        print("[LlamaIndex][ERROR] Failed to build index:", e)
-
-
-# Initialise LlamaIndex once at startup (but don't crash if it fails).
-init_llama_index()
-
-
-def llama_query_impl(query: str, series: Optional[str], top_k: int = 5) -> Dict[str, Any]:
-    """
-    Internal helper: run a similarity search over dream texts.
-    Returns answer+sources, but still completely side-channel to the existing API.
-    """
-    if not LLAMA_ENABLED or LLAMA_INDEX is None:
-        return {
-            "enabled": False,
-            "answer": "",
-            "sources": [],
-            "error": LLAMA_INIT_ERROR or "LlamaIndex is not enabled on this server.",
-        }
-
-    from llama_index.core import VectorStoreIndex  # type: ignore
-
-    # Basic safety
-    query = (query or "").strip()
-    if not query:
-        return {
-            "enabled": True,
-            "answer": "No query text provided.",
-            "sources": [],
-            "error": None,
+        pil_image = decode_image(data['image'])
+        
+        # Optimize for Gemini 2.0 Flash (JPEG, Quality 80)
+        img_byte_arr = io.BytesIO()
+        pil_image.save(img_byte_arr, format='JPEG', quality=80)
+        img_bytes = img_byte_arr.getvalue()
+
+        # Strict Schema: Unity needs a boolean, not a chat
+        schema = {
+            "type": "OBJECT",
+            "properties": {
+                "verified": {"type": "BOOLEAN"},
+                "confidence": {"type": "NUMBER"},
+                "feedback": {"type": "STRING"}
+            },
+            "required": ["verified", "feedback"]
         }
 
-    top_k = max(1, min(int(top_k or 5), 10))
-
-    try:
-        filters = None
-        if series:
-            try:
-                # Newer LlamaIndex metadata filter API
-                from llama_index.core.vector_stores.types import (
-                    MetadataFilters,
-                    ExactMatchFilter,
-                )
-                filters = MetadataFilters(
-                    filters=[ExactMatchFilter(key="series", value=str(series))]
-                )
-            except Exception:
-                # If metadata filter types move around, just ignore filters and search globally.
-                filters = None
-
-        # Retrieval-only
-        retriever = LLAMA_INDEX.as_retriever(
-            similarity_top_k=top_k,
-            filters=filters,
-        )
-        nodes = retriever.retrieve(query)
-
-        sources = []
-        answer_snippets = []
-        for n in nodes:
-            meta = getattr(n, "metadata", {}) or {}
-            text = getattr(n, "text", "") or ""
-            sources.append(
-                {
-                    "id": meta.get("id"),
-                    "series": meta.get("series"),
-                    "source": meta.get("source"),
-                    "text": text,
-                }
-            )
-            answer_snippets.append(text[:500])
-
-        if not answer_snippets:
-            answer = "No relevant dreams were retrieved for this query."
-        else:
-            answer = (
-                "Top matching dream snippets (retrieved via LlamaIndex):\n\n"
-                + "\n\n---\n\n".join(answer_snippets)
+        prompt = f"""
+        You are the 'Eye of the Spellbook'.
+        Look at this image. Is the user holding a '{target}'?
+        Note: If the target is 'wand', accept a pen, pencil, or stick.
+        Return JSON.
+        """
+
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",
+            contents=[prompt, types.Part.from_bytes(data=img_bytes, mime_type="image/jpeg")],
+            config=types.GenerateContentConfig(
+                response_mime_type="application/json",
+                response_schema=schema,
+                temperature=0.1
             )
+        )
 
-        return {
-            "enabled": True,
-            "answer": answer,
-            "sources": sources,
-            "error": None,
-        }
+        result = json.loads(response.text)
+        emit('vision_result', result)
 
     except Exception as e:
-        return {
-            "enabled": True,
-            "answer": "",
-            "sources": [],
-            "error": f"LlamaIndex retrieval failed: {e}",
-        }
-
+        print(f"Vision Error: {e}")
+        emit('vision_result', {"verified": False, "feedback": "Server vision error."})
 
-# -------------------------------------------------------------------
-# Flask app
-# -------------------------------------------------------------------
 
-app = Flask(__name__)
+# ==========================================
+# 2. PRONUNCIATION ASSESSMENT (The Spell)
+# ==========================================
+@socketio.on('assess_pronunciation')
+def handle_pronunciation(data):
+    """
+    Called when user speaks the spell.
+    Payload: { 'audio': 'base64_wav...', 'text': 'Turn this pencil into a wand', 'lang': 'en-US' }
+    """
+    ref_text = data.get('text')
+    lang = data.get('lang', 'en-US')
+    print(f"🎤 Audio Check: '{ref_text}' in {lang}")
 
-# ---------------- HOME ROUTE (NEW) ----------------
-
-@app.route("/", methods=["GET"])
-def home() -> Any:
-    """Landing page describing the MCP server and its tools."""
-    return jsonify({
-        "status": "DreamBiomeMCP is running",
-        "description": "Flask server exposing real dream and sleep data via HTTP tools.",
-        "endpoints": [
-            {"method": "GET", "path": "/health", "desc": "Server health and data counts"},
-            {"method": "GET", "path": "/dream/series", "desc": "List available dream series"},
-            {"method": "POST", "path": "/dream/samples", "desc": "Get random dream samples (filters: series, min/max words)"},
-            {"method": "POST", "path": "/dream/cluster-stats", "desc": "Get statistical summary of a dream cluster"},
-            {"method": "GET", "path": "/sleep/profiles", "desc": "List available sleep profile IDs"},
-            {"method": "GET", "path": "/sleep/profile/<id>", "desc": "Get full hypnogram data for a specific profile"},
-            {"method": "POST", "path": "/sleep/profile-arc", "desc": "Get narrative 4-act arc derived from sleep stages"},
-            {"method": "POST", "path": "/seed/random-dream-biome", "desc": "Get a random seed (dream + sleep + region)"},
-            {"method": "POST", "path": "/llama/query", "desc": "RAG search over dream texts"},
-        ]
-    })
-
-
-@app.route("/health", methods=["GET"])
-def health() -> Any:
-    return jsonify({
-        "status": "ok",
-        "dreams": len(ALL_DREAMS),
-        "sleep_profiles": len(ALL_SLEEP_PROFILES),
-        "llama_enabled": LLAMA_ENABLED,
-        "llama_error": LLAMA_INIT_ERROR,
-    })
-
-
-# ---------------- DREAM ENDPOINTS ----------------
-
-@app.route("/dream/series", methods=["GET"])
-def list_dream_series() -> Any:
-    series_counts: Dict[str, int] = {}
-    for d in ALL_DREAMS:
-        series = str(d.get("series") or "unknown")
-        series_counts[series] = series_counts.get(series, 0) + 1
-
-    data = [{"series": s, "count": c} for s, c in sorted(series_counts.items(), key=lambda kv: kv[0])]
-    return jsonify({"series": data})
-
-
-@app.route("/dream/samples", methods=["POST"])
-def dream_samples() -> Any:
-    payload = request.get_json(force=True, silent=True) or {}
-    source = payload.get("source")
-    series = payload.get("series")
-    n = int(payload.get("n", 5))
-    min_words = payload.get("min_words")
-    max_words = payload.get("max_words")
-
-    dreams = filter_dreams(
-        source=source,
-        series=series,
-        min_words=int(min_words) if min_words is not None else None,
-        max_words=int(max_words) if max_words is not None else None,
-    )
-
-    if not dreams:
-        return jsonify({"samples": [], "note": "No dreams matched the filter."})
-
-    random.shuffle(dreams)
-    samples = dreams[: max(1, n)]
-    return jsonify({"samples": samples})
-
-
-@app.route("/dream/cluster-stats", methods=["POST"])
-def dream_cluster_stats() -> Any:
-    payload = request.get_json(force=True, silent=True) or {}
-    source = payload.get("source")
-    series = payload.get("series")
-    min_words = payload.get("min_words")
-    max_words = payload.get("max_words")
-
-    dreams = filter_dreams(
-        source=source,
-        series=series,
-        min_words=int(min_words) if min_words is not None else None,
-        max_words=int(max_words) if max_words is not None else None,
-    )
-
-    stats = summarise_dream_cluster(dreams)
-    stats["source"] = source
-    stats["series"] = series
-    return jsonify(stats)
-
-
-# ---------------- SLEEP ENDPOINTS ----------------
-
-@app.route("/sleep/profiles", methods=["GET"])
-def list_sleep_profiles() -> Any:
-    # Return only IDs + high-level summary to keep payload small
-    summaries = []
-    for p in ALL_SLEEP_PROFILES:
-        summaries.append(
-            {
-                "id": p["id"],
-                "total_sleep_time_min": p.get("total_sleep_time_min"),
-                "sleep_efficiency": p.get("sleep_efficiency"),
-                "rem_percentage": p.get("rem_percentage"),
-                "awakenings": p.get("awakenings"),
-            }
+    temp_wav_path = None
+    try:
+        # Save Base64 to Temp File
+        audio_bytes = base64.b64decode(data['audio'])
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_wav:
+            temp_wav.write(audio_bytes)
+            temp_wav_path = temp_wav.name
+
+        # Azure Config
+        speech_config = speechsdk.SpeechConfig(subscription=AZURE_SPEECH_KEY, region=AZURE_SPEECH_REGION)
+        speech_config.speech_recognition_language = lang
+        audio_config = speechsdk.audio.AudioConfig(filename=temp_wav_path)
+
+        # Config Assessment (Phoneme level for strictness)
+        pronunciation_config = speechsdk.PronunciationAssessmentConfig(
+            reference_text=ref_text,
+            grading_system=speechsdk.PronunciationAssessmentGradingSystem.HundredMark,
+            granularity=speechsdk.PronunciationAssessmentGranularity.Phoneme,
+            enable_miscue=True
         )
-    return jsonify({"profiles": summaries})
-
 
-@app.route("/sleep/profile/<profile_id>", methods=["GET"])
-def get_sleep_profile(profile_id: str) -> Any:
-    profile = SLEEP_INDEX.get(profile_id)
-    if not profile:
-        return jsonify({"error": f"Sleep profile '{profile_id}' not found."}), 404
-    return jsonify(profile)
+        recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
+        pronunciation_config.apply_to(recognizer)
 
+        # Recognize
+        result = recognizer.recognize_once_async().get()
 
-@app.route("/sleep/profile-arc", methods=["POST"])
-def sleep_profile_arc() -> Any:
-    payload = request.get_json(force=True, silent=True) or {}
-    profile_id = payload.get("profile_id")
-    if not profile_id:
-        return jsonify({"error": "profile_id is required"}), 400
+        # Cleanup
+        if os.path.exists(temp_wav_path):
+            os.remove(temp_wav_path)
 
-    profile = SLEEP_INDEX.get(profile_id)
-    if not profile:
-        return jsonify({"error": f"Sleep profile '{profile_id}' not found."}), 404
-
-    arc = compute_sleep_arc(profile)
-    return jsonify({"profile_id": profile_id, "arc": arc})
+        # Process Results
+        if result.reason == speechsdk.ResultReason.RecognizedSpeech:
+            pron_result = speechsdk.PronunciationAssessmentResult(result)
+            response = {
+                "success": True,
+                "score": pron_result.accuracy_score,
+                "fluency": pron_result.fluency_score,
+                "recognized_text": result.text
+            }
+        else:
+            response = {"success": False, "score": 0, "recognized_text": "Silence or Noise"}
+        
+        emit('pronunciation_result', response)
 
+    except Exception as e:
+        print(f"Audio Error: {e}")
+        if temp_wav_path and os.path.exists(temp_wav_path):
+            os.remove(temp_wav_path)
+        emit('pronunciation_result', {"success": False, "score": 0, "error": str(e)})
 
-# ---------------- COMBINED SEED ----------------
 
-@app.route("/seed/random-dream-biome", methods=["POST", "GET"])
-def random_dream_biome_seed() -> Any:
-    """Return a bundle: one random dream, one random sleep profile, and one region context."""
-    dream = random.choice(ALL_DREAMS) if ALL_DREAMS else None
-    sleep_profile = random.choice(ALL_SLEEP_PROFILES) if ALL_SLEEP_PROFILES else None
-    region = pick_random_region_context()
+# ==========================================
+# 3. HANDWRITING/OCR (The Book Task)
+# ==========================================
+@socketio.on('verify_writing')
+def handle_writing_verification(data):
+    """
+    Called when user writes on the book.
+    Payload: { 'image': 'base64...', 'expected_word': 'of' }
+    """
+    expected = data.get('expected_word', 'of')
+    print(f"📖 Book Check: Looking for word '{expected}'")
 
-    return jsonify(
-        {
-            "dream_sample": dream,
-            "sleep_profile": sleep_profile,
-            "region_sleep": region,
+    try:
+        pil_image = decode_image(data['image'])
+        
+        img_byte_arr = io.BytesIO()
+        pil_image.save(img_byte_arr, format='JPEG', quality=80)
+        img_bytes = img_byte_arr.getvalue()
+
+        schema = {
+            "type": "OBJECT",
+            "properties": {
+                "correct": {"type": "BOOLEAN"},
+                "detected_text": {"type": "STRING"}
+            },
+            "required": ["correct", "detected_text"]
         }
-    )
-
-
-# ---------------- LLAMAINDEX QUERY (NEW) ----------------
 
-@app.route("/llama/query", methods=["POST"])
-def llama_query() -> Any:
-    """
-    LlamaIndex-backed retrieval over dream texts.
-    This is additive – frontend doesn't need to change unless you want to use it.
-    """
-    payload = request.get_json(force=True, silent=True) or {}
-    query = payload.get("query", "")
-    series = payload.get("series")
-    top_k = payload.get("top_k", 5)
+        prompt = f"""
+        Analyze the handwriting or text on the book cover in this image.
+        Does it say "{expected}"? (Ignore capitalization).
+        Return JSON.
+        """
+
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",
+            contents=[prompt, types.Part.from_bytes(data=img_bytes, mime_type="image/jpeg")],
+            config=types.GenerateContentConfig(
+                response_mime_type="application/json",
+                response_schema=schema
+            )
+        )
 
-    result = llama_query_impl(query, series, top_k=top_k)
-    status = 200 if result.get("error") is None else 500
-    return jsonify(result), status
+        result = json.loads(response.text)
+        emit('writing_result', result)
 
+    except Exception as e:
+        print(f"OCR Error: {e}")
+        emit('writing_result', {"correct": False, "detected_text": "Error"})
 
-# -------------------------------------------------------------------
-# Entry point
-# -------------------------------------------------------------------
 
-if __name__ == "__main__":
-    # For local testing; HF Spaces will just run `python main.py`
-    app.run(host="0.0.0.0", port=7860, debug=False)
+if __name__ == '__main__':
+    # Standard entry point for Gunicorn (handled in Dockerfile)
+    socketio.run(app, host='0.0.0.0', port=7860)