Update main.py

main.py

@@ -1,5 +1,6 @@
 # main.py
 import os
+import uuid
 import logging
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
@@ -7,7 +8,7 @@ from fastapi.responses import FileResponse, Response
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 import requests
-from typing import Optional
+from typing import Optional, Any, Dict
 
 # -------------------------------
 # CONFIGURACIÓN DE LOGGING
@@ -19,63 +20,45 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 # -------------------------------
-# CARGA DEL FLOW_API_URL DESDE SECRETS
+# CARGA DE SECRETS
 # -------------------------------
 FLOW_API_URL = os.getenv("FLOW_API_URL")
-if FLOW_API_URL is None:
-    raise RuntimeError("❌ FLOW_API_URL no está definido. Agregalo en los Secrets de Hugging Face.")
+API_KEY        = os.getenv("LANGFLOW_API_KEY")
+if not FLOW_API_URL:
+    raise RuntimeError("❌ FLOW_API_URL no está definido. Agrégalo en los Secrets de Hugging Face.")
+if not API_KEY:
+    raise RuntimeError("❌ LANGFLOW_API_KEY no está definido. Agrégalo en los Secrets de Hugging Face.")
 
 logger.info(f"✅ FLOW_API_URL configurado: {FLOW_API_URL[:30]}...")
+logger.info(f"✅ LANGFLOW_API_KEY cargada (longitud {len(API_KEY)})")
 
 # -------------------------------
 # INICIALIZACIÓN DE LA APP
 # -------------------------------
 app = FastAPI()
-
-# Middleware CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Montar carpeta estática
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
-# Ruta principal: servir index.html
 @app.get("/")
 async def serve_index():
     return FileResponse("static/index.html")
 
-# -------------------------------
-# LOGO FALLBACK HANDLER
-# -------------------------------
 @app.get("/static/te.png")
 async def serve_logo():
     logo_path = "static/te.png"
     if os.path.exists(logo_path):
         return FileResponse(logo_path)
-    else:
-        svg_content = '''<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
-  <!-- Fondo circular -->
-  <circle cx="20" cy="20" r="18" fill="#f6ae2d"/>
-  <!-- Ojo estilizado -->
-  <g transform="translate(20, 20)">
-    <path d="M -12 0 Q -6 -6 0 -6 Q 6 -6 12 0 Q 6 6 0 6 Q -6 6 -12 0" fill="#420909" stroke="none"/>
-    <circle cx="0" cy="0" r="5" fill="#f6ae2d"/>
-    <circle cx="0" cy="0" r="3" fill="#420909"/>
-    <circle cx="-1" cy="-1" r="1" fill="white" opacity="0.8"/>
-  </g>
-  <text x="20" y="35" font-family="Arial, sans-serif" font-size="8" font-weight="bold"
-        text-anchor="middle" fill="#420909">TE</text>
-</svg>'''
-        return Response(content=svg_content, media_type="image/svg+xml",
-                        headers={"Cache-Control": "public, max-age=3600"})
+    svg = '''<svg width="40" height="40" ...>...</svg>'''  # placeholder SVG
+    return Response(svg, media_type="image/svg+xml", headers={"Cache-Control":"public, max-age=3600"})
 
 # -------------------------------
-# MODELO DE ENTRADA / SALIDA
+# MODELOS DE Pydantic
 # -------------------------------
 class AnalyzeRequest(BaseModel):
     url: str
@@ -86,116 +69,94 @@ class AnalyzeResponse(BaseModel):
     error: Optional[str] = None
 
 # -------------------------------
-# ENDPOINT DE ANÁLISIS
+# HELPER DE EXTRACCIÓN
+# -------------------------------
+def _extract_text_from_response(data: Any) -> Optional[str]:
+    if isinstance(data, str):
+        return data
+    if isinstance(data, dict):
+        for key in ("outputs","result","message","text","content"):
+            val = data.get(key)
+            if isinstance(val, str):
+                return val
+            elif val is not None:
+                txt = _extract_text_from_response(val)
+                if txt:
+                    return txt
+        for val in data.values():
+            txt = _extract_text_from_response(val)
+            if txt:
+                return txt
+    if isinstance(data, list):
+        for item in data:
+            txt = _extract_text_from_response(item)
+            if txt:
+                return txt
+    return None
+
+# -------------------------------
+# ENDPOINT /analyze
 # -------------------------------
 @app.post("/analyze", response_model=AnalyzeResponse)
 async def analyze(request: AnalyzeRequest):
     logger.info(f"📥 Recibida solicitud de análisis para URL: {request.url}")
+    session_id = str(uuid.uuid4())
+    payload = {
+        "input_value":       request.url,
+        "input_type":        "chat",
+        "output_type":       "chat",
+        "session_id":        session_id,
+        "output_component":  "",
+        "tweaks":            None
+    }
+    headers = {
+        "Content-Type": "application/json",
+        "User-Agent":    "TrueEye-HuggingFace-Space/1.0",
+        "x-api-key":     API_KEY
+    }
+
     try:
-        payload = {
-            "input_value": request.url,
-            "output_type": "chat",
-            "input_type": "chat",
-            "tweaks": {}
-        }
-        headers = {
-            "Content-Type": "application/json",
-            "User-Agent": "TrueEye-HuggingFace-Space/1.0"
-        }
         logger.info("📤 Enviando petición a Langflow...")
         logger.debug(f"Payload: {payload}")
-
-        response = requests.post(
-            FLOW_API_URL,
-            json=payload,
-            headers=headers,
-            timeout=300
-        )
-        logger.info(f"📨 Respuesta recibida. Status: {response.status_code}")
-        response.raise_for_status()
-
-        data = response.json()
-        logger.debug(f"Respuesta JSON: {data}")
-
-        # Extracción de texto
-        result_text = None
-        if isinstance(data, dict) and "result" in data:
-            result_text = data["result"]
-        elif isinstance(data, dict) and "outputs" in data:
-            outputs = data["outputs"]
-            if outputs and isinstance(outputs, list):
-                for node in outputs[0].get("outputs", []):
-                    if "message" in node:
-                        msg = node["message"]
-                        result_text = msg.get("text") if isinstance(msg, dict) else str(msg)
-                        break
+        resp = requests.post(FLOW_API_URL, json=payload, headers=headers, timeout=300)
+        logger.info(f"📨 Respuesta recibida. Status: {resp.status_code}")
+        resp.raise_for_status()
+        data = resp.json()
+        logger.debug(f"Respuesta JSON completa: {data}")
+
+        # Extraer texto final
+        result_text = _extract_text_from_response(data)
         if not result_text:
-            result_text = _extract_text_from_response(data) or \
-                          "⚠️ Se procesó la solicitud pero no se pudo extraer el resultado."
+            logger.warning("⚠️ No se pudo extraer texto de la respuesta")
+            result_text = "⚠️ Se procesó la solicitud pero no se pudo extraer el resultado."
 
         logger.info("✅ Análisis completado exitosamente")
         return AnalyzeResponse(result=result_text)
 
     except requests.exceptions.Timeout:
         logger.error("⏱️ Timeout en la petición a Langflow")
-        return AnalyzeResponse(
-            result="❌ Error: La solicitud tardó demasiado tiempo.",
-            success=False,
-            error="timeout"
-        )
-
-    except requests.exceptions.ConnectionError as e:
-        logger.error(f"🔌 Error de conexión: {e}")
-        return AnalyzeResponse(
-            result="❌ Error: No se pudo conectar con el servicio de análisis.",
-            success=False,
-            error="connection"
-        )
+        return AnalyzeResponse(result="❌ Error: Timeout (el análisis tardó demasiado)", success=False, error="timeout")
 
     except requests.exceptions.HTTPError as e:
-        # <-- Aquí mejora el logging para capturar el body del 500 interno
-        status = e.response.status_code if e.response else "unknown"
-        body   = e.response.text        if e.response else ""
-        logger.error(f"🚫 Error HTTP {status} al llamar al Flow. Body de error:\n{body}")
+        body = e.response.text if e.response is not None else "<no body>"
+        logger.error(f"🚫 Error HTTP {e.response.status_code if e.response else ''}: {body}")
         return AnalyzeResponse(
-            result=f"❌ Error del servidor (HTTP {status}). Revisa los logs internos.",
+            result=f"❌ Error HTTP al llamar al Flow: {body}",
             success=False,
-            error=f"http_{status}"
+            error=f"http_{e.response.status_code if e.response else 'unknown'}"
         )
 
     except Exception as e:
-        logger.exception(f"💥 Error inesperado: {e}")
-        return AnalyzeResponse(
-            result=f"❌ Error inesperado: {str(e)}",
-            success=False,
-            error="unknown"
-        )
-
-def _extract_text_from_response(data):
-    if isinstance(data, str):
-        return data
-    if isinstance(data, dict):
-        for key in ['text', 'message', 'result', 'output', 'content']:
-            if key in data:
-                return _extract_text_from_response(data[key]) if isinstance(data[key], (dict, list)) else data[key]
-        for value in data.values():
-            txt = _extract_text_from_response(value)
-            if txt:
-                return txt
-    if isinstance(data, list):
-        for item in data:
-            txt = _extract_text_from_response(item)
-            if txt:
-                return txt
-    return None
+        logger.exception("💥 Error inesperado en /analyze")
+        return AnalyzeResponse(result=f"❌ Error inesperado: {e}", success=False, error="unknown")
 
 # -------------------------------
-# ENDPOINT DE SALUD
+# HEALTHCHECK
 # -------------------------------
 @app.get("/health")
 async def health_check():
     return {
         "status": "healthy",
-        "flow_configured": bool(FLOW_API_URL),
-        "service": "TrueEye Reports"
+        "flow_url":   bool(FLOW_API_URL),
+        "service":    "TrueEye Reports"
     }