evolutia 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

evolutia/__init__.py

@@ -1,5 +1,14 @@
 from .evolutia_engine import EvolutiaEngine
 from .variation_generator import VariationGenerator
 from .llm_providers import LLMProvider, get_provider
+from .exceptions import (
+    EvolutiaError,
+    ConfigurationError,
+    ProviderError,
+    ValidationError,
+    MaterialExtractionError,
+    ExamGenerationError,
+    RAGError
+)
 
 __version__ = "0.1.1"

evolutia/async_llm_providers.py

@@ -0,0 +1,157 @@
+"""
+Proveedores asíncronos de LLM para EvolutIA.
+Usa asyncio para llamadas concurrentes a APIs de LLM.
+"""
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+from functools import wraps
+
+from .retry_utils import retry_async
+
+logger = logging.getLogger(__name__)
+
+
+def async_sync_wrapper(sync_func):
+    """
+    Wrapper para ejecutar funciones síncronas de forma asíncrona usando run_in_executor.
+
+    Args:
+        sync_func: Función síncrona a envolver
+
+    Returns:
+        Función asíncrona que ejecuta la función síncrona en un executor
+    """
+    @wraps(sync_func)
+    async def async_wrapper(*args, **kwargs):
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, sync_func, *args, **kwargs)
+    return async_wrapper
+
+
+class AsyncLLMProvider(ABC):
+    """Clase base abstracta para proveedores asíncronos de LLM."""
+
+    DEFAULT_SYSTEM_PROMPT = "Eres un experto en métodos matemáticos para física e ingeniería."
+    DEFAULT_MAX_TOKENS = 2000
+    DEFAULT_TEMPERATURE = 0.7
+
+    def __init__(self, model_name: Optional[str] = None):
+        """
+        Inicializa el proveedor asíncrono de LLM.
+
+        Args:
+            model_name: Nombre del modelo a usar
+        """
+        self.model_name = model_name
+
+    @abstractmethod
+    async def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """Genera contenido de forma asíncrona."""
+        pass
+
+
+class AsyncOpenAIProvider(AsyncLLMProvider):
+    """Proveedor asíncrono para OpenAI."""
+
+    def __init__(self, model_name: Optional[str] = None):
+        super().__init__(model_name)
+        self.sync_provider = None
+
+        try:
+            from evolutia.llm_providers import OpenAIProvider
+            self.sync_provider = OpenAIProvider(model_name=model_name)
+            logger.debug("[AsyncOpenAIProvider] Inicializado con proveedor síncrono")
+        except Exception as e:
+            logger.error(f"[AsyncOpenAIProvider] Error inicializando proveedor síncrono: {e}")
+
+    @retry_async(max_retries=3, initial_delay=1.0, max_delay=10.0)
+    async def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """Genera contenido usando el proveedor síncrono en un executor."""
+        if not self.sync_provider:
+            return None
+
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            None,
+            self.sync_provider.generate_content,
+            prompt,
+            system_prompt,
+            kwargs
+        )
+        return result
+
+
+class AsyncAnthropicProvider(AsyncLLMProvider):
+    """Proveedor asíncrono para Anthropic."""
+
+    def __init__(self, model_name: Optional[str] = None):
+        super().__init__(model_name)
+        self.sync_provider = None
+
+        try:
+            from evolutia.llm_providers import AnthropicProvider
+            self.sync_provider = AnthropicProvider(model_name=model_name)
+            logger.debug("[AsyncAnthropicProvider] Inicializado con proveedor síncrono")
+        except Exception as e:
+            logger.error(f"[AsyncAnthropicProvider] Error inicializando proveedor síncrono: {e}")
+
+    @retry_async(max_retries=3, initial_delay=1.0, max_delay=10.0)
+    async def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """Genera contenido usando el proveedor síncrono en un executor."""
+        if not self.sync_provider:
+            return None
+
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            None,
+            self.sync_provider.generate_content,
+            prompt,
+            system_prompt,
+            kwargs
+        )
+        return result
+
+
+class AsyncGeminiProvider(AsyncLLMProvider):
+    """Proveedor asíncrono para Gemini."""
+
+    def __init__(self, model_name: Optional[str] = None):
+        super().__init__(model_name)
+        self.sync_provider = None
+
+        try:
+            from evolutia.llm_providers import GeminiProvider
+            self.sync_provider = GeminiProvider(model_name=model_name)
+            logger.debug("[AsyncGeminiProvider] Inicializado con proveedor síncrono")
+        except Exception as e:
+            logger.error(f"[AsyncGeminiProvider] Error inicializando proveedor síncrono: {e}")
+
+    @retry_async(max_retries=3, initial_delay=1.0, max_delay=10.0)
+    async def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """Genera contenido usando el proveedor síncrono en un executor."""
+        if not self.sync_provider:
+            return None
+
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(
+            None,
+            self.sync_provider.generate_content,
+            prompt,
+            system_prompt,
+            kwargs
+        )
+        return result
+
+
+def get_async_provider(provider_name: str, **kwargs) -> AsyncLLMProvider:
+    """Factory method para obtener un proveedor asíncrono."""
+    if provider_name == "openai":
+        return AsyncOpenAIProvider(**kwargs)
+    elif provider_name == "anthropic":
+        return AsyncAnthropicProvider(**kwargs)
+    elif provider_name == "gemini":
+        return AsyncGeminiProvider(**kwargs)
+    else:
+        raise ValueError(f"Proveedor asíncrono desconocido: {provider_name}")

evolutia/cache/__init__.py

@@ -0,0 +1,9 @@
+"""
+Paquete de caché para EvolutIA.
+Proporciona sistemas de caché para respuestas LLM, análisis de ejercicios y embeddings.
+"""
+
+from .llm_cache import LLMCache
+from .exercise_cache import ExerciseAnalysisCache
+
+__all__ = ['LLMCache', 'ExerciseAnalysisCache']

evolutia/cache/exercise_cache.py

@@ -0,0 +1,226 @@
+"""
+Caché de análisis de ejercicios para EvolutIA.
+Reduce tiempo de ejecución almacenando análisis de ejercicios.
+"""
+import hashlib
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class ExerciseAnalysisCache:
+    """
+    Sistema de caché para análisis de ejercicios.
+
+    Características:
+    - Persistencia en disco por defecto
+    - Basado en hash del contenido del ejercicio
+    - Valida integridad del caché
+    - Logging de cache hits y misses
+    """
+
+    def __init__(self, cache_dir: Optional[Path] = None, enabled: bool = True):
+        """
+        Inicializa el caché de análisis de ejercicios.
+
+        Args:
+            cache_dir: Directorio para caché (defecto: ./storage/cache/exercises)
+            enabled: Si False, el caché está deshabilitado (pasa a través)
+        """
+        self.enabled = enabled
+
+        if cache_dir is None:
+            cache_dir = Path('./storage/cache/exercises')
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self.hits = 0
+        self.misses = 0
+
+        if self.enabled:
+            logger.info(f"[ExerciseAnalysisCache] Inicializado: {self.cache_dir}")
+        else:
+            logger.info("[ExerciseAnalysisCache] Deshabilitado")
+
+    def _get_cache_file(self, content_hash: str) -> Path:
+        """
+        Obtiene la ruta del archivo de caché para un hash.
+
+        Args:
+            content_hash: Hash del contenido del ejercicio
+
+        Returns:
+            Ruta del archivo de caché
+        """
+        return self.cache_dir / f"{content_hash}.json"
+
+    def _hash_content(self, content: str) -> str:
+        """
+        Genera un hash SHA256 del contenido.
+
+        Args:
+            content: Contenido del ejercicio
+
+        Returns:
+            Hash SHA256 hexadecimal
+        """
+        return hashlib.sha256(content.encode()).hexdigest()
+
+    def get(self, exercise: Dict) -> Optional[Dict]:
+        """
+        Obtiene el análisis cacheado de un ejercicio.
+
+        Args:
+            exercise: Diccionario del ejercicio con campo 'content'
+
+        Returns:
+            Análisis cacheado si existe, None en caso contrario
+        """
+        if not self.enabled:
+            return None
+
+        content = exercise.get('content', '')
+        if not content:
+            self.misses += 1
+            return None
+
+        content_hash = self._hash_content(content)
+        cache_file = self._get_cache_file(content_hash)
+
+        if not cache_file.exists():
+            self.misses += 1
+            logger.debug("[ExerciseAnalysisCache] Cache miss")
+            return None
+
+        try:
+            with open(cache_file, 'r', encoding='utf-8') as f:
+                analysis = json.load(f)
+
+            self.hits += 1
+            logger.info(
+                f"[ExerciseAnalysisCache] Cache HIT "
+                f"(hit_rate={self.hit_rate:.1%})"
+            )
+            return analysis
+        except Exception as e:
+            logger.warning(f"[ExerciseAnalysisCache] Error leyendo caché: {e}")
+            self.misses += 1
+            return None
+
+    def put(self, exercise: Dict, analysis: Dict) -> bool:
+        """
+        Almacena el análisis de un ejercicio en caché.
+
+        Args:
+            exercise: Diccionario del ejercicio con campo 'content'
+            analysis: Análisis del ejercicio
+
+        Returns:
+            True si se almacenó exitosamente, False si hubo error
+        """
+        if not self.enabled:
+            return False
+
+        content = exercise.get('content', '')
+        if not content:
+            logger.debug("[ExerciseAnalysisCache] Rechazando ejercicio sin contenido")
+            return False
+
+        # Validar que el análisis tiene los campos mínimos
+        required_fields = ['total_complexity']
+        if not all(field in analysis for field in required_fields):
+            logger.warning("[ExerciseAnalysisCache] Análisis incompleto, no cachéando")
+            return False
+
+        content_hash = self._hash_content(content)
+        cache_file = self._get_cache_file(content_hash)
+
+        try:
+            # Almacenar análisis con metadata
+            cache_data = {
+                'analysis': analysis,
+                'metadata': {
+                    'cached_at': None,  # Se llenará después
+                    'content_length': len(content),
+                    'exercise_label': exercise.get('label', 'unknown')
+                }
+            }
+
+            import time
+            cache_data['metadata']['cached_at'] = time.time()
+
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.debug(f"[ExerciseAnalysisCache] Análisis cachéado: {cache_file.name}")
+            return True
+        except Exception as e:
+            logger.warning(f"[ExerciseAnalysisCache] Error guardando caché: {e}")
+            return False
+
+    def clear(self):
+        """Limpia todo el caché de ejercicios."""
+        if not self.enabled:
+            return
+
+        initial_count = len(list(self.cache_dir.glob('*.json')))
+
+        for cache_file in self.cache_dir.glob('*.json'):
+            try:
+                cache_file.unlink()
+            except Exception as e:
+                logger.warning(f"[ExerciseAnalysisCache] Error eliminando {cache_file}: {e}")
+
+        self.hits = 0
+        self.misses = 0
+
+        logger.info(f"[ExerciseAnalysisCache] Caché limpiado (eliminados {initial_count} archivos)")
+
+    def get_stats(self) -> Dict[str, any]:
+        """
+        Obtiene estadísticas del caché.
+
+        Returns:
+            Diccionario con estadísticas
+        """
+        cache_files = list(self.cache_dir.glob('*.json'))
+        total_requests = self.hits + self.misses
+        hit_rate = self.hits / total_requests if total_requests > 0 else 0.0
+
+        return {
+            'entries': len(cache_files),
+            'hits': self.hits,
+            'misses': self.misses,
+            'hit_rate': hit_rate,
+            'enabled': self.enabled,
+            'cache_dir': str(self.cache_dir)
+        }
+
+    @property
+    def hit_rate(self) -> float:
+        """
+        Tasa de aciertos del caché.
+
+        Returns:
+            Proporción de aciertos (0.0 a 1.0)
+        """
+        total_requests = self.hits + self.misses
+        return self.hits / total_requests if total_requests > 0 else 0.0
+
+    def __len__(self) -> int:
+        """Retorna el número de entradas en caché."""
+        if not self.enabled:
+            return 0
+        return len(list(self.cache_dir.glob('*.json')))
+
+    def __repr__(self) -> str:
+        """Representación del caché."""
+        status = "enabled" if self.enabled else "disabled"
+        return (
+            f"ExerciseAnalysisCache(status={status}, "
+            f"entries={len(self)}, hits={self.hits}, "
+            f"misses={self.misses}, hit_rate={self.hit_rate:.1%})"
+        )