whispad_ai_processor.py

#!/usr/bin/env python3
"""
AI Response Processor para WhisPad
Extrae y procesa JSON de respuestas de IA para quiz y flashcards

Integra con:
- OpenAI GPT-4o (proveedor principal de prueba)
- Sistema de backend existente de WhisPad
- Endpoints /api/generate-quiz y /api/generate-flashcards
"""

import json
import re
import asyncio
import aiohttp
import os
from typing import Dict, List, Any, Optional, Union
from datetime import datetime
import logging

# Configurar logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


class WhisPadAIProcessor:
    """Procesador de respuestas de IA específico para WhisPad"""
    
    def __init__(self):
        self.json_extraction_patterns = [
            # JSON en bloques de código
            r'```(?:json)?\s*(\{.*?\})\s*```',
            r'```(?:json)?\s*(\[.*?\])\s*```',
            # JSON directo
            r'(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})',
            r'(\[[^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*\])',
        ]
        
        # Schemas esperados para WhisPad
        self.quiz_schema = {
            "questions": "array",
        }
        
        self.flashcard_schema = {
            "flashcards": "array",
        }
    
    def extract_quiz_json(self, ai_response: str) -> Optional[Dict[str, Any]]:
        """
        Extrae JSON de quiz de la respuesta de IA
        
        Formato esperado:
        {
            "questions": [
                {
                    "question": "¿Pregunta?",
                    "answers": ["A", "B", "C", "D"],
                    "correct": 0
                }
            ]
        }
        """
        try:
            json_objects = self._extract_json_objects(ai_response)
            
            for obj in json_objects:
                if self._validate_quiz_structure(obj):
                    logger.info(f"✅ Quiz JSON válido extraído: {len(obj.get('questions', []))} preguntas")
                    return obj
            
            logger.warning("❌ No se encontró JSON de quiz válido en la respuesta")
            return None
            
        except Exception as e:
            logger.error(f"Error extrayendo quiz JSON: {e}")
            return None
    
    def extract_flashcards_json(self, ai_response: str) -> Optional[Dict[str, Any]]:
        """
        Extrae JSON de flashcards de la respuesta de IA
        
        Formato esperado:
        {
            "flashcards": [
                {
                    "front": "Concepto o pregunta",
                    "back": "Definición o respuesta"
                }
            ]
        }
        """
        try:
            json_objects = self._extract_json_objects(ai_response)
            
            for obj in json_objects:
                if self._validate_flashcard_structure(obj):
                    logger.info(f"✅ Flashcards JSON válido extraído: {len(obj.get('flashcards', []))} tarjetas")
                    return obj
            
            logger.warning("❌ No se encontró JSON de flashcards válido en la respuesta")
            return None
            
        except Exception as e:
            logger.error(f"Error extrayendo flashcards JSON: {e}")
            return None
    
    def _extract_json_objects(self, text: str) -> List[Dict[str, Any]]:
        """Extrae todos los objetos JSON de un texto"""
        json_objects = []
        
        # Limpiar texto
        cleaned_text = self._clean_response_text(text)
        
        # Intentar parsear texto completo como JSON
        try:
            parsed = json.loads(cleaned_text.strip())
            if isinstance(parsed, dict):
                json_objects.append(parsed)
                return json_objects
        except json.JSONDecodeError:
            pass
        
        # Usar patrones regex para extraer JSON
        for pattern in self.json_extraction_patterns:
            matches = re.finditer(pattern, cleaned_text, re.DOTALL | re.MULTILINE)
            for match in matches:
                json_str = match.group(1)
                try:
                    parsed = json.loads(json_str)
                    if isinstance(parsed, dict) and parsed not in json_objects:
                        json_objects.append(parsed)
                except json.JSONDecodeError:
                    continue
        
        return json_objects
    
    def _clean_response_text(self, text: str) -> str:
        """Limpia el texto de la respuesta de IA"""
        # Remover caracteres de control
        text = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', '', text)
        
        # Remover líneas de explicación comunes
        lines_to_remove = [
            r'^.*aquí.*quiz.*$',
            r'^.*he generado.*$',
            r'^.*flashcards.*solicitaste.*$',
            r'^.*estos son.*$',
            r'^.*espero.*útil.*$',
        ]
        
        lines = text.split('\n')
        filtered_lines = []
        
        for line in lines:
            should_keep = True
            for remove_pattern in lines_to_remove:
                if re.match(remove_pattern, line.strip(), re.IGNORECASE):
                    should_keep = False
                    break
            
            if should_keep:
                filtered_lines.append(line)
        
        return '\n'.join(filtered_lines)
    
    def _validate_quiz_structure(self, obj: Dict[str, Any]) -> bool:
        """Valida la estructura de un quiz JSON"""
        try:
            # Debe tener campo 'questions'
            if 'questions' not in obj:
                return False
            
            questions = obj['questions']
            if not isinstance(questions, list) or len(questions) == 0:
                return False
            
            # Validar cada pregunta
            for q in questions:
                if not isinstance(q, dict):
                    return False
                
                required_fields = ['question', 'answers', 'correct']
                for field in required_fields:
                    if field not in q:
                        return False
                
                # Validar tipos
                if not isinstance(q['question'], str):
                    return False
                if not isinstance(q['answers'], list) or len(q['answers']) < 2:
                    return False
                if not isinstance(q['correct'], int) or q['correct'] < 0 or q['correct'] >= len(q['answers']):
                    return False
            
            return True
            
        except Exception as e:
            logger.error(f"Error validando estructura de quiz: {e}")
            return False
    
    def _validate_flashcard_structure(self, obj: Dict[str, Any]) -> bool:
        """Valida la estructura de flashcards JSON"""
        try:
            # Debe tener campo 'flashcards'
            if 'flashcards' not in obj:
                return False
            
            flashcards = obj['flashcards']
            if not isinstance(flashcards, list) or len(flashcards) == 0:
                return False
            
            # Validar cada flashcard
            for card in flashcards:
                if not isinstance(card, dict):
                    return False
                
                required_fields = ['front', 'back']
                for field in required_fields:
                    if field not in card:
                        return False
                    if not isinstance(card[field], str) or not card[field].strip():
                        return False
            
            return True
            
        except Exception as e:
            logger.error(f"Error validando estructura de flashcards: {e}")
            return False


class OpenAITestClient:
    """Cliente de prueba para OpenAI API"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.openai.com/v1"
    
    async def generate_quiz(self, content: str, difficulty: str = "medium", num_questions: int = 5) -> str:
        """Genera un quiz usando OpenAI GPT-4o"""
        
        prompt = f"""Genera un quiz de {num_questions} preguntas basado en el siguiente contenido.
Dificultad: {difficulty}

Contenido:
{content}

Responde ÚNICAMENTE con JSON válido en este formato exacto:
{{
    "questions": [
        {{
            "question": "Texto de la pregunta",
            "answers": ["Opción A", "Opción B", "Opción C", "Opción D"],
            "correct": 0
        }}
    ]
}}

No incluyas texto explicativo antes o después del JSON."""
        
        return await self._call_api(prompt)
    
    async def generate_flashcards(self, content: str, num_cards: int = 5) -> str:
        """Genera flashcards usando OpenAI GPT-4o"""
        
        prompt = f"""Genera {num_cards} flashcards basadas en el siguiente contenido.

Contenido:
{content}

Responde ÚNICAMENTE con JSON válido en este formato exacto:
{{
    "flashcards": [
        {{
            "front": "Concepto o pregunta",
            "back": "Definición o respuesta"
        }}
    ]
}}

No incluyas texto explicativo antes o después del JSON."""
        
        return await self._call_api(prompt)
    
    async def _call_api(self, prompt: str) -> str:
        """Realiza llamada a OpenAI API"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        data = {
            "model": "gpt-4o",
            "messages": [
                {
                    "role": "system",
                    "content": "Eres un experto en educación. Responde únicamente con JSON válido, sin texto adicional."
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            "max_tokens": 2000,
            "temperature": 0.2,
            "response_format": {"type": "json_object"}  # Forzar JSON en GPT-4o
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(f"{self.base_url}/chat/completions", 
                                   headers=headers, json=data) as response:
                if response.status == 200:
                    result = await response.json()
                    return result["choices"][0]["message"]["content"]
                else:
                    error_text = await response.text()
                    raise Exception(f"OpenAI API error {response.status}: {error_text}")


async def test_quiz_generation():
    """Prueba la generación y extracción de quiz"""
    logger.info("\n=== PRUEBA: GENERACIÓN DE QUIZ ===")
    
    api_key = os.getenv('OPENAI_API_KEY')
    if not api_key:
        logger.warning("OPENAI_API_KEY no configurada. Usando respuesta simulada.")
        
        # Respuesta simulada realista
        simulated_response = '''Aquí tienes el quiz solicitado:

```json
{
    "questions": [
        {
            "question": "¿Cuál es la función principal de una variable en programación?",
            "answers": [
                "Almacenar datos temporalmente",
                "Ejecutar código",
                "Compilar programas",
                "Crear interfaces"
            ],
            "correct": 0
        },
        {
            "question": "¿Qué significa 'debugging' en programación?",
            "answers": [
                "Escribir código nuevo",
                "Buscar y corregir errores",
                "Compilar un programa",
                "Documentar código"
            ],
            "correct": 1
        }
    ]
}
```

Este quiz está diseñado para evaluar conocimientos básicos de programación.'''
        
        processor = WhisPadAIProcessor()
        quiz_data = processor.extract_quiz_json(simulated_response)
        
        if quiz_data:
            logger.info("✅ Quiz extraído exitosamente de respuesta simulada")
            logger.info(f"Número de preguntas: {len(quiz_data['questions'])}")
            for i, q in enumerate(quiz_data['questions'], 1):
                logger.info(f"Pregunta {i}: {q['question'][:50]}...")
        else:
            logger.error("❌ Falló la extracción del quiz simulado")
        
        return
    
    # Prueba con API real
    client = OpenAITestClient(api_key)
    processor = WhisPadAIProcessor()
    
    sample_content = """
    Python es un lenguaje de programación de alto nivel. 
    Es conocido por su sintaxis clara y legible.
    Las variables en Python se declaran dinámicamente.
    Python soporta múltiples paradigmas de programación.
    """
    
    try:
        response = await client.generate_quiz(sample_content, "medium", 3)
        logger.info(f"Respuesta de OpenAI: {response}")
        
        quiz_data = processor.extract_quiz_json(response)
        
        if quiz_data:
            logger.info("✅ Quiz extraído exitosamente de API real")
            logger.info(f"Número de preguntas: {len(quiz_data['questions'])}")
            for i, q in enumerate(quiz_data['questions'], 1):
                logger.info(f"Pregunta {i}: {q['question']}")
                logger.info(f"Respuesta correcta: {q['answers'][q['correct']]}")
        else:
            logger.error("❌ Falló la extracción del quiz de API real")
            
    except Exception as e:
        logger.error(f"Error en prueba de API real: {e}")


async def test_flashcard_generation():
    """Prueba la generación y extracción de flashcards"""
    logger.info("\n=== PRUEBA: GENERACIÓN DE FLASHCARDS ===")
    
    api_key = os.getenv('OPENAI_API_KEY')
    if not api_key:
        logger.warning("OPENAI_API_KEY no configurada. Usando respuesta simulada.")
        
        # Respuesta simulada realista
        simulated_response = '''Te proporciono las flashcards solicitadas:

{
    "flashcards": [
        {
            "front": "¿Qué es una función en programación?",
            "back": "Un bloque de código reutilizable que realiza una tarea específica"
        },
        {
            "front": "¿Qué es un bucle for?",
            "back": "Una estructura de control que repite un bloque de código un número determinado de veces"
        },
        {
            "front": "¿Qué es una lista en Python?",
            "back": "Una estructura de datos ordenada y mutable que puede contener elementos de diferentes tipos"
        }
    ]
}

Estas flashcards te ayudarán a estudiar conceptos básicos de programación.'''
        
        processor = WhisPadAIProcessor()
        flashcard_data = processor.extract_flashcards_json(simulated_response)
        
        if flashcard_data:
            logger.info("✅ Flashcards extraídas exitosamente de respuesta simulada")
            logger.info(f"Número de tarjetas: {len(flashcard_data['flashcards'])}")
            for i, card in enumerate(flashcard_data['flashcards'], 1):
                logger.info(f"Tarjeta {i}: {card['front'][:40]}...")
        else:
            logger.error("❌ Falló la extracción de flashcards simuladas")
        
        return
    
    # Prueba con API real
    client = OpenAITestClient(api_key)
    processor = WhisPadAIProcessor()
    
    sample_content = """
    JavaScript es un lenguaje de programación interpretado.
    Se ejecuta principalmente en navegadores web.
    Las variables se pueden declarar con var, let, o const.
    JavaScript es débilmente tipado y dinámico.
    """
    
    try:
        response = await client.generate_flashcards(sample_content, 3)
        logger.info(f"Respuesta de OpenAI: {response}")
        
        flashcard_data = processor.extract_flashcards_json(response)
        
        if flashcard_data:
            logger.info("✅ Flashcards extraídas exitosamente de API real")
            logger.info(f"Número de tarjetas: {len(flashcard_data['flashcards'])}")
            for i, card in enumerate(flashcard_data['flashcards'], 1):
                logger.info(f"Tarjeta {i}:")
                logger.info(f"  Frente: {card['front']}")
                logger.info(f"  Atrás: {card['back']}")
        else:
            logger.error("❌ Falló la extracción de flashcards de API real")
            
    except Exception as e:
        logger.error(f"Error en prueba de API real: {e}")


def test_edge_cases():
    """Prueba casos extremos y errores"""
    logger.info("\n=== PRUEBA: CASOS EXTREMOS ===")
    
    processor = WhisPadAIProcessor()
    
    test_cases = [
        {
            "name": "JSON malformado",
            "response": '{"questions": [{"question": "Test", "answers": ["A", "B"]',
            "type": "quiz"
        },
        {
            "name": "Respuesta sin JSON",
            "response": "Lo siento, no puedo generar el contenido solicitado.",
            "type": "quiz"
        },
        {
            "name": "JSON con estructura incorrecta",
            "response": '{"wrong_field": ["data"]}',
            "type": "quiz"
        },
        {
            "name": "Quiz con pregunta sin respuestas suficientes",
            "response": '{"questions": [{"question": "Test", "answers": ["Solo una"], "correct": 0}]}',
            "type": "quiz"
        }
    ]
    
    for test in test_cases:
        logger.info(f"\n--- {test['name']} ---")
        
        if test['type'] == 'quiz':
            result = processor.extract_quiz_json(test['response'])
        else:
            result = processor.extract_flashcards_json(test['response'])
        
        if result is None:
            logger.info("✅ Correctamente rechazado caso inválido")
        else:
            logger.warning("⚠️ Caso inválido no fue rechazado")


async def main():
    """Función principal de pruebas"""
    logger.info("=== WHISPAD AI RESPONSE PROCESSOR ===")
    logger.info("Proveedor de prueba: OpenAI GPT-4o")
    logger.info("Funcionalidades: Quiz y Flashcards")
    logger.info("=" * 50)
    
    # Ejecutar todas las pruebas
    await test_quiz_generation()
    await test_flashcard_generation()
    test_edge_cases()
    
    logger.info("\n" + "=" * 50)
    logger.info("RESUMEN DE PRUEBAS:")
    logger.info("✅ Extractor de JSON robusto implementado")
    logger.info("✅ Validación de estructura específica para WhisPad")
    logger.info("✅ Manejo de casos extremos y errores")
    logger.info("✅ Compatible con OpenAI GPT-4o y Structured Outputs")
    logger.info("✅ Integrable con endpoints existentes de WhisPad")
    
    logger.info("\nINSTRUCCIONES DE USO:")
    logger.info("1. Configurar OPENAI_API_KEY para pruebas reales")
    logger.info("2. Integrar WhisPadAIProcessor en backend.py")
    logger.info("3. Usar extract_quiz_json() y extract_flashcards_json()")
    logger.info("4. El procesador filtra automáticamente respuestas inválidas")


if __name__ == "__main__":
    asyncio.run(main())