Update main.py

main.py

@@ -1,11 +1,22 @@
 # main.py
 import os
-from fastapi import FastAPI
+import logging
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 import requests
+from typing import Optional
+
+# -------------------------------
+# CONFIGURACIÓN DE LOGGING
+# -------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 # -------------------------------
 # CARGA DEL FLOW_API_URL DESDE SECRETS
@@ -14,6 +25,9 @@ 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.")
 
+# Log para verificar la URL (sin mostrar la URL completa por seguridad)
+logger.info(f"✅ FLOW_API_URL configurado: {FLOW_API_URL[:30]}...")
+
 # -------------------------------
 # INICIALIZACIÓN DE LA APP
 # -------------------------------
@@ -22,7 +36,7 @@ app = FastAPI()
 # Middleware CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Podés restringir esto si querés
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -42,24 +56,160 @@ async def serve_index():
 class AnalyzeRequest(BaseModel):
     url: str
 
+class AnalyzeResponse(BaseModel):
+    result: str
+    success: bool = True
+    error: Optional[str] = None
+
 # -------------------------------
 # ENDPOINT DE ANÁLISIS
 # -------------------------------
-@app.post("/analyze")
+@app.post("/analyze", response_model=AnalyzeResponse)
 async def analyze(request: AnalyzeRequest):
+    logger.info(f"📥 Recibida solicitud de análisis para URL: {request.url}")
+    
     try:
+        # IMPORTANTE: El flow espera un mensaje de chat que contenga la URL,
+        # no la URL directamente. El ChatInput procesará el mensaje y 
+        # el URLComponent extraerá la URL del texto.
         payload = {
-            "input_value": request.url,
+            "input_value": request.url,  # El ChatInput recibirá esto como mensaje
             "output_type": "chat",
-            "input_type": "chat"
+            "input_type": "chat",
+            "tweaks": {}  # Agregar tweaks vacío por si acaso
         }
-        headers = {"Content-Type": "application/json"}
-        response = requests.post(FLOW_API_URL, json=payload, headers=headers)
+        
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "TrueEye-HuggingFace-Space/1.0"
+        }
+        
+        logger.info(f"📤 Enviando petición a Langflow...")
+        logger.debug(f"Payload: {payload}")
+        
+        # Hacer la petición con timeout de 300 segundos (5 minutos)
+        # dado que el flow tiene múltiples llamadas a modelos LLM
+        response = requests.post(
+            FLOW_API_URL, 
+            json=payload, 
+            headers=headers,
+            timeout=300  # 5 minutos de timeout
+        )
+        
+        logger.info(f"📨 Respuesta recibida. Status: {response.status_code}")
+        
+        # Verificar el status de la respuesta
         response.raise_for_status()
+        
+        # Parsear la respuesta
         data = response.json()
-        result_text = data.get("result", "⚠️ No se encontró respuesta en el output.")
-        return {"result": result_text}
-    except requests.exceptions.RequestException as e:
-        return {"result": f"❌ Error al conectarse al Flow: {e}"}
+        logger.debug(f"Respuesta JSON: {data}")
+        
+        # El formato de respuesta de Langflow puede variar
+        # Intentar extraer el resultado de diferentes formas
+        result_text = None
+        
+        # Opción 1: Respuesta directa en 'result'
+        if isinstance(data, dict) and "result" in data:
+            result_text = data["result"]
+        
+        # Opción 2: Respuesta en formato de outputs
+        elif isinstance(data, dict) and "outputs" in data:
+            outputs = data["outputs"]
+            if isinstance(outputs, list) and len(outputs) > 0:
+                output = outputs[0]
+                if "outputs" in output:
+                    # Buscar el ChatOutput
+                    for node_output in output["outputs"]:
+                        if "message" in node_output:
+                            if isinstance(node_output["message"], dict):
+                                result_text = node_output["message"].get("text", "")
+                            else:
+                                result_text = str(node_output["message"])
+                            break
+        
+        # Opción 3: Intentar extraer de cualquier estructura
+        if not result_text and isinstance(data, dict):
+            # Buscar recursivamente cualquier campo 'text' o 'message'
+            result_text = _extract_text_from_response(data)
+        
+        if not result_text:
+            logger.warning("⚠️ No se pudo extraer texto de la respuesta")
+            result_text = "⚠️ Se procesó la solicitud pero no se pudo extraer el resultado. Respuesta recibida: " + str(data)[:200]
+        
+        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. El análisis puede ser muy complejo o el servicio está sobrecargado.",
+            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. Verifica que el FLOW_API_URL esté correctamente configurado.",
+            success=False,
+            error="connection"
+        )
+    except requests.exceptions.HTTPError as e:
+        logger.error(f"🚫 Error HTTP: {e}")
+        logger.error(f"Respuesta del servidor: {e.response.text if e.response else 'No hay respuesta'}")
+        return AnalyzeResponse(
+            result=f"❌ Error del servidor: {e}. Verifica que el flow esté activo y funcionando.",
+            success=False,
+            error=f"http_{e.response.status_code if e.response else 'unknown'}"
+        )
     except Exception as e:
-        return {"result": f"❌ Error inesperado: {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):
+    """Función auxiliar para extraer texto de una respuesta compleja"""
+    if isinstance(data, str):
+        return data
+    
+    if isinstance(data, dict):
+        # Buscar campos comunes
+        for key in ['text', 'message', 'result', 'output', 'content']:
+            if key in data:
+                value = data[key]
+                if isinstance(value, str):
+                    return value
+                elif isinstance(value, dict) or isinstance(value, list):
+                    result = _extract_text_from_response(value)
+                    if result:
+                        return result
+        
+        # Si no encontramos campos conocidos, buscar en todos los valores
+        for value in data.values():
+            if isinstance(value, (dict, list)):
+                result = _extract_text_from_response(value)
+                if result:
+                    return result
+    
+    elif isinstance(data, list):
+        for item in data:
+            result = _extract_text_from_response(item)
+            if result:
+                return result
+    
+    return None
+
+# -------------------------------
+# ENDPOINT DE SALUD
+# -------------------------------
+@app.get("/health")
+async def health_check():
+    """Endpoint para verificar que el servicio está funcionando"""
+    return {
+        "status": "healthy",
+        "flow_configured": bool(FLOW_API_URL),
+        "service": "TrueEye Reports"
+    }