Update index.html

index.html

@@ -3,48 +3,21 @@ import json
 import logging
 import io
 import time
-from typing import Optional
+from typing import Dict, Any
 
-from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi import FastAPI, UploadFile, File, HTTPException, Depends
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, Field, field_validator
 from groq import Groq, APIError
 import pdfplumber
 
 # ==================== CONFIGURACIÓN ====================
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Obtener API key de los secrets de Hugging Face
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-if not GROQ_API_KEY:
-    logger.warning("GROQ_API_KEY no está configurada en los secrets de Hugging Face")
-
-# ==================== CONSTANTES ====================
-MAX_TEXT_LENGTH = 4000
-MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
-MAX_RETRIES = 2
-EXPECTED_KEYS = {'grice_maxims', 'pragmatics', 'ambiguity', 'fallacies'}
-
-# ==================== INICIALIZACIÓN ====================
-app = FastAPI(
-    title="PragmaLens API",
-    description="API para análisis pragmático de textos",
-    version="1.0.0"
-)
+app = FastAPI(title="PragmaLens API", version="1.1.0")
 
-# Inicializar cliente solo si hay API key
-client = None
-if GROQ_API_KEY:
-    client = Groq(api_key=GROQ_API_KEY)
-else:
-    logger.warning("Groq client no inicializado: falta API key")
-
-# Middleware CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -52,293 +25,64 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Middleware para logging de tiempo de respuesta
-@app.middleware("http")
-async def add_process_time_header(request, call_next):
-    start_time = time.time()
-    response = await call_next(request)
-    process_time = time.time() - start_time
-    response.headers["X-Process-Time"] = str(process_time)
-    logger.info(f"{request.method} {request.url.path} - {process_time:.3f}s")
-    return response
+# ==================== DEPENDENCIAS ====================
+def get_groq_client():
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise HTTPException(status_code=500, detail="GROQ_API_KEY no configurada")
+    return Groq(api_key=api_key)
 
-# ==================== MODELOS ====================
+# ==================== MODELOS (Pydantic V2) ====================
 class TextInput(BaseModel):
-    text: str
+    text: str = Field(..., min_length=1)
     
-    @validator('text')
-    def text_not_empty(cls, v):
-        if not v or not v.strip():
+    @field_validator('text')
+    @classmethod
+    def text_not_empty(cls, v: str) -> str:
+        if not v.strip():
             raise ValueError('El texto no puede estar vacío')
         return v.strip()
 
-# ==================== FUNCIONES PRINCIPALES ====================
-def run_audit(text: str) -> dict:
-    """
-    Ejecuta el análisis del texto usando Groq API con reintentos
-    """
-    # Verificar que el cliente esté inicializado
-    if not client:
-        return {
-            "grice_maxims": "⚠️ API key no configurada. Configura GROQ_API_KEY en los secrets de Hugging Face",
-            "pragmatics": "⚠️ API key no configurada. Configura GROQ_API_KEY en los secrets de Hugging Face",
-            "ambiguity": "⚠️ API key no configurada. Configura GROQ_API_KEY en los secrets de Hugging Face",
-            "fallacies": "⚠️ API key no configurada. Configura GROQ_API_KEY en los secrets de Hugging Face"
-        }
-    
-    # Truncar texto si es necesario
-    if len(text) > MAX_TEXT_LENGTH:
-        logger.warning(f"Texto truncado de {len(text)} a {MAX_TEXT_LENGTH} caracteres")
-        text = text[:MAX_TEXT_LENGTH] + "..."
-    
+# ==================== LÓGICA ====================
+def run_audit(text: str, client: Groq) -> Dict[str, str]:
     system_prompt = (
-        "You are a senior discourse analyst. Analyze the text for: "
-        "1. Grice's Maxims violations (Quantity, Quality, Relation, Manner)\n"
-        "2. Pragmatic markers and features (speech acts, implicature, deixis)\n"
-        "3. Ambiguity cases (lexical, syntactic, pragmatic)\n"
-        "4. Logical fallacies and argumentative flaws (ad hominem, straw man, etc.)\n\n"
-        "Return a JSON object with these exact keys: "
-        "grice_maxims, pragmatics, ambiguity, fallacies. "
-        "Each value MUST be a single, continuous string description. "
-        "No nested objects, no arrays, no lists. "
-        "If no issues found, state 'No significant issues detected'. "
-        "Be specific and cite examples from the text when possible."
+        "You are a senior discourse analyst. Analyze for: 1. Grice's Maxims, "
+        "2. Pragmatic markers, 3. Ambiguity, 4. Logical fallacies. "
+        "Return ONLY a raw JSON object with keys: grice_maxims, pragmatics, ambiguity, fallacies. "
+        "Each value must be a single continuous string."
     )
     
-    for attempt in range(MAX_RETRIES):
-        try:
-            logger.info(f"Intentando análisis (intento {attempt + 1}/{MAX_RETRIES})")
-            
-            response = client.chat.completions.create(
-                model="llama-3.3-70b-versatile",
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": text}
-                ],
-                response_format={"type": "json_object"},
-                temperature=0.1,
-                max_tokens=1000,
-                timeout=30.0
-            )
-            
-            content = response.choices[0].message.content
-            result = json.loads(content)
-            
-            # Validar y completar estructura
-            for key in EXPECTED_KEYS:
-                if key not in result:
-                    result[key] = "No information provided"
-                elif not isinstance(result[key], str):
-                    # Si es objeto o array, convertir a string legible
-                    if isinstance(result[key], (dict, list)):
-                        result[key] = json.dumps(result[key], ensure_ascii=False)
-                    else:
-                        result[key] = str(result[key])
-            
-            logger.info("Análisis completado exitosamente")
-            return result
-            
-        except (APIError, json.JSONDecodeError) as e:
-            logger.warning(f"Intento {attempt + 1} fallido: {str(e)}")
-            if attempt == MAX_RETRIES - 1:
-                logger.error(f"Todos los intentos fallaron: {str(e)}")
-                return {
-                    "grice_maxims": f"❌ Error: {str(e)[:150]}",
-                    "pragmatics": f"❌ Error: {str(e)[:150]}",
-                    "ambiguity": f"❌ Error: {str(e)[:150]}",
-                    "fallacies": f"❌ Error: {str(e)[:150]}"
-                }
-            time.sleep(2 ** attempt)
-            
-        except Exception as e:
-            logger.error(f"Error inesperado: {str(e)}")
-            return {
-                "grice_maxims": f"❌ Error inesperado: {str(e)[:150]}",
-                "pragmatics": f"❌ Error inesperado: {str(e)[:150]}",
-                "ambiguity": f"❌ Error inesperado: {str(e)[:150]}",
-                "fallacies": f"❌ Error inesperado: {str(e)[:150]}"
-            }
-    
-    # Fallback
-    return {
-        "grice_maxims": "Error processing",
-        "pragmatics": "Error processing",
-        "ambiguity": "Error processing",
-        "fallacies": "Error processing"
-    }
-
-def extract_text_from_pdf(content: bytes) -> str:
-    """
-    Extrae texto de un archivo PDF
-    """
     try:
-        with pdfplumber.open(io.BytesIO(content)) as pdf:
-            text_parts = []
-            for page_num, page in enumerate(pdf.pages, 1):
-                page_text = page.extract_text()
-                if page_text:
-                    text_parts.append(page_text)
-                else:
-                    logger.warning(f"Página {page_num} no tiene texto extraíble")
-            
-            full_text = "\n".join(text_parts)
-            
-            if not full_text.strip():
-                raise HTTPException(
-                    status_code=400,
-                    detail="No se pudo extraer texto del PDF. El archivo podría estar vacío o ser una imagen escaneada."
-                )
-            
-            return full_text
-            
-    except pdfplumber.PDFSyntaxError:
-        raise HTTPException(
-            status_code=400,
-            detail="El archivo no es un PDF válido o está corrupto"
+        response = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": text[:4000]}],
+            response_format={"type": "json_object"},
+            temperature=0.1
         )
+        return json.loads(response.choices[0].message.content)
     except Exception as e:
-        logger.error(f"Error procesando PDF: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error al procesar el PDF: {str(e)}"
-        )
+        logger.error(f"Error en auditoría: {e}")
+        return {k: "Error procesando el análisis" for k in ['grice_maxims', 'pragmatics', 'ambiguity', 'fallacies']}
 
 # ==================== ENDPOINTS ====================
 @app.get("/")
 async def root():
-    """
-    Endpoint raíz que devuelve la interfaz HTML
-    """
-    try:
-        return FileResponse("index.html")
-    except FileNotFoundError:
-        logger.warning("index.html no encontrado")
-        return JSONResponse(
-            status_code=404,
-            content={
-                "detail": "index.html no encontrado",
-                "message": "La interfaz web no está disponible"
-            }
-        )
-
-@app.get("/health")
-async def health_check():
-    """
-    Endpoint para verificar el estado del servicio
-    """
-    status = {
-        "status": "healthy",
-        "groq": "configured" if client else "not configured",
-        "timestamp": time.time()
-    }
-    
-    if client:
-        try:
-            # Verificar conexión con Groq
-            client.models.list()
-            status["groq"] = "connected"
-        except Exception as e:
-            logger.error(f"Health check - Groq error: {str(e)}")
-            status["groq"] = "error"
-            status["groq_error"] = str(e)
-    
-    return status
+    return FileResponse("index.html")
 
 @app.post("/analyze")
-async def analyze(payload: TextInput):
-    """
-    Analiza un texto enviado directamente
-    """
-    try:
-        logger.info(f"Recibida solicitud de análisis de texto ({len(payload.text)} caracteres)")
-        result = run_audit(payload.text)
-        return result
-    except Exception as e:
-        logger.error(f"Error en /analyze: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error procesando la solicitud: {str(e)}"
-        )
+async def analyze(payload: TextInput, client: Groq = Depends(get_groq_client)):
+    return run_audit(payload.text, client)
 
 @app.post("/analyze_pdf")
-async def analyze_pdf(file: UploadFile = File(...)):
-    """
-    Analiza un archivo PDF subido
-    """
-    # Validar tipo de archivo
-    if not file.filename or not file.filename.lower().endswith('.pdf'):
-        raise HTTPException(
-            status_code=400,
-            detail="Solo se aceptan archivos PDF"
-        )
+async def analyze_pdf(file: UploadFile = File(...), client: Groq = Depends(get_groq_client)):
+    if not file.filename.endswith('.pdf'):
+        raise HTTPException(status_code=400, detail="Solo archivos PDF")
     
-    # Leer y validar tamaño
-    try:
-        content = await file.read()
-        file_size = len(content)
-        logger.info(f"PDF recibido: {file.filename}, tamaño: {file_size} bytes")
-        
-        if file_size == 0:
-            raise HTTPException(
-                status_code=400,
-                detail="El archivo está vacío"
-            )
-        
-        if file_size > MAX_FILE_SIZE:
-            raise HTTPException(
-                status_code=400,
-                detail=f"El archivo excede el tamaño máximo permitido ({MAX_FILE_SIZE // (1024*1024)}MB)"
-            )
-        
-        # Extraer texto
-        text = extract_text_from_pdf(content)
-        logger.info(f"Texto extraído del PDF: {len(text)} caracteres")
-        
-        # Analizar
-        result = run_audit(text)
-        return result
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error en /analyze_pdf: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error procesando el PDF: {str(e)}"
-        )
-
-# ==================== MANEJADORES DE ERRORES GLOBALES ====================
-@app.exception_handler(HTTPException)
-async def http_exception_handler(request, exc):
-    logger.warning(f"HTTP Exception: {exc.detail}")
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={
-            "detail": exc.detail,
-            "status_code": exc.status_code
-        }
-    )
-
-@app.exception_handler(Exception)
-async def general_exception_handler(request, exc):
-    logger.error(f"Excepción no manejada: {str(exc)}", exc_info=True)
-    return JSONResponse(
-        status_code=500,
-        content={
-            "detail": "Error interno del servidor",
-            "status_code": 500
-        }
-    )
-
-# ==================== PUNTO DE ENTRADA ====================
-if __name__ == "__main__":
-    import uvicorn
+    content = await file.read()
+    with pdfplumber.open(io.BytesIO(content)) as pdf:
+        text = "\n".join([p.extract_text() or "" for p in pdf.pages[:10]])
     
-    logger.info("Iniciando PragmaLens API en Hugging Face...")
-    port = int(os.getenv("PORT", 7860))
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=port,
-        log_level="info"
-    )
+    return run_audit(text, client)
+
+# ==================== ENTRY POINT ====================
+# Para ejecutar localmente: uvicorn main:app --reload