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

evolutia/llm_providers.py

@@ -4,23 +4,38 @@ Módulo que define los proveedores de LLM abstractos y concretos.
 import os
 import logging
 from abc import ABC, abstractmethod
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union, TYPE_CHECKING
 
 logger = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from evolutia.cache.llm_cache import LLMCache
+
 class LLMProvider(ABC):
     """Clase base abstracta para proveedores de LLM."""
 
-    def __init__(self, model_name: Optional[str] = None):
+    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, cache: Optional['LLMCache'] = None):
+        """
+        Inicializa el proveedor de LLM.
+
+        Args:
+            model_name: Nombre del modelo a usar
+            cache: Instancia opcional de LLMCache para cachear respuestas
+        """
         self.model_name = model_name
         self.client = None
-        self.genai = None # For Gemini
+        self.genai = None
+        self.cache = cache
         self.api_key = self._get_api_key()
         if self.api_key:
             self._setup_client()
-        else:
-             # Some providers like local might not strictly need an API key from env
-             pass
+
+        if self.cache:
+            logger.debug(f"[LLMProvider] Caché de LLM habilitado")
 
     @abstractmethod
     def _get_api_key(self) -> Optional[str]:
@@ -37,30 +52,86 @@ class LLMProvider(ABC):
         """Genera contenido a partir de un prompt."""
         pass
 
+    def _get_provider_name(self) -> str:
+        """
+        Obtiene el nombre del proveedor para usar en el caché.
 
-class OpenAIProvider(LLMProvider):
-    """Proveedor para OpenAI."""
+        Returns:
+            Nombre del proveedor (ej: 'OpenAI', 'Anthropic')
+        """
+        return self.__class__.__name__.replace('Provider', '')
 
-    def _get_api_key(self) -> Optional[str]:
-        key = os.getenv("OPENAI_API_KEY")
-        if not key:
-            logger.warning("OPENAI_API_KEY no encontrada")
-        return key
 
-    def _setup_client(self):
+class OpenAICompatibleProvider(LLMProvider):
+    """Base clase para proveedores compatibles con OpenAI API."""
+
+    def __init__(self, model_name: Optional[str] = None, base_url: Optional[str] = None, timeout: Optional[float] = None, cache: Optional['LLMCache'] = None):
+        """
+        Inicializa el proveedor OpenAI-compatible.
+
+        Args:
+            model_name: Nombre del modelo a usar
+            base_url: URL base de la API (para proveedores compatibles)
+            timeout: Timeout para las llamadas a la API
+            cache: Instancia opcional de LLMCache
+        """
+        self.base_url = base_url
+        self.timeout = timeout
+        super().__init__(model_name, cache=cache)
+
+    def _setup_openai_client(self, api_key: Optional[str], base_url: Optional[str] = None, timeout: Optional[float] = None) -> bool:
+        """
+        Configura cliente OpenAI compartido.
+
+        Returns:
+            True si la configuración fue exitosa
+            False si no se pudo configurar (cliente no inicializado)
+        """
+        if not api_key:
+            return False
         try:
             from openai import OpenAI
-            self.client = OpenAI(api_key=self.api_key)
+            client_kwargs = {"api_key": api_key}
+            if base_url:
+                client_kwargs["base_url"] = base_url
+            if timeout is not None:
+                client_kwargs["timeout"] = timeout
+            self.client = OpenAI(**client_kwargs)
+            logger.info(f"[OpenAICompatibleProvider] Cliente OpenAI inicializado (base_url={base_url}, timeout={timeout})")
+            return True
         except ImportError:
-            logger.error("Biblioteca openai no instalada. Instala con: pip install openai")
+            logger.error("[OpenAICompatibleProvider] Biblioteca openai no instalada. Instala con: pip install openai")
+            self.client = None
+            return False
+        except Exception as e:
+            logger.error(f"[OpenAICompatibleProvider] Error inesperado inicializando cliente OpenAI: {e}")
             self.client = None
+            return False
+
+    def _openai_generate_content(self, provider_name: str, default_model: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """
+        Genera contenido usando API OpenAI-compatible con caché.
+
+        Returns:
+            Contenido generado si la llamada fue exitosa
+            None si hubo un error de API o configuración
+        """
+        if not self.client:
+            logger.error(f"[{provider_name}] Cliente no inicializado, no se puede generar contenido")
+            return None
 
-    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
-        if not self.client: return None
-        
-        system_content = system_prompt or "Eres un experto en métodos matemáticos para física e ingeniería."
-        model = self.model_name or "gpt-4"
-        
+        system_content = system_prompt or self.DEFAULT_SYSTEM_PROMPT
+        model = self.model_name or default_model
+        prompt = kwargs.get("prompt", "")
+
+        # Intentar caché primero
+        if self.cache:
+            cached = self.cache.get(prompt, self._get_provider_name(), model)
+            if cached:
+                logger.info(f"[{provider_name}] Contenido obtenido del caché (modelo={model})")
+                return cached
+
+        # Generar respuesta
         try:
             response = self.client.chat.completions.create(
                 model=model,
@@ -68,15 +139,44 @@ class OpenAIProvider(LLMProvider):
                     {"role": "system", "content": system_content},
                     {"role": "user", "content": prompt}
                 ],
-                temperature=kwargs.get("temperature", 0.7),
-                max_tokens=kwargs.get("max_tokens", 2000)
+                temperature=kwargs.get("temperature", self.DEFAULT_TEMPERATURE),
+                max_tokens=kwargs.get("max_tokens", self.DEFAULT_MAX_TOKENS)
             )
-            return response.choices[0].message.content.strip()
+            content = response.choices[0].message.content.strip()
+            logger.info(f"[{provider_name}] Contenido generado exitosamente (modelo={model}, longitud={len(content)})")
+
+            # Guardar en caché
+            if self.cache:
+                metadata = {
+                    'provider': provider_name,
+                    'model': model,
+                    'temperature': kwargs.get("temperature", self.DEFAULT_TEMPERATURE),
+                    'max_tokens': kwargs.get("max_tokens", self.DEFAULT_MAX_TOKENS)
+                }
+                self.cache.put(prompt, provider_name, model, content, metadata=metadata)
+
+            return content
         except Exception as e:
-            logger.error(f"Error llamando a OpenAI API: {e}")
+            logger.error(f"[{provider_name}] Error en llamada a API: {e}")
             return None
 
 
+class OpenAIProvider(OpenAICompatibleProvider):
+    """Proveedor para OpenAI."""
+
+    def _get_api_key(self) -> Optional[str]:
+        key = os.getenv("OPENAI_API_KEY")
+        if not key:
+            logger.warning("OPENAI_API_KEY no encontrada")
+        return key
+
+    def _setup_client(self):
+        self._setup_openai_client(self.api_key)
+
+    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        return self._openai_generate_content("OpenAI", "gpt-4", system_prompt, prompt=prompt, **kwargs)
+
+
 class AnthropicProvider(LLMProvider):
     """Proveedor para Anthropic (Claude)."""
 
@@ -99,7 +199,16 @@ class AnthropicProvider(LLMProvider):
 
         system_content = system_prompt or "Eres un experto en métodos matemáticos para física e ingeniería."
         model = self.model_name or "claude-3-opus-20240229"
+        provider_name = self._get_provider_name()
+
+        # Intentar caché primero
+        if self.cache:
+            cached = self.cache.get(prompt, provider_name, model)
+            if cached:
+                logger.info(f"[{provider_name}] Contenido obtenido del caché (modelo={model})")
+                return cached
 
+        # Generar respuesta
         try:
             message = self.client.messages.create(
                 model=model,
@@ -108,9 +217,22 @@ class AnthropicProvider(LLMProvider):
                 system=system_content,
                 messages=[{"role": "user", "content": prompt}]
             )
-            return message.content[0].text.strip()
+            content = message.content[0].text.strip()
+            logger.info(f"[{provider_name}] Contenido generado exitosamente (modelo={model}, longitud={len(content)})")
+
+            # Guardar en caché
+            if self.cache:
+                metadata = {
+                    'provider': provider_name,
+                    'model': model,
+                    'temperature': kwargs.get("temperature", 0.7),
+                    'max_tokens': kwargs.get("max_tokens", 2000)
+                }
+                self.cache.put(prompt, provider_name, model, content, metadata=metadata)
+
+            return content
         except Exception as e:
-            logger.error(f"Error llamando a Anthropic API: {e}")
+            logger.error(f"[{provider_name}] Error llamando a Anthropic API: {e}")
             return None
 
 
@@ -137,6 +259,14 @@ class GeminiProvider(LLMProvider):
 
         model_name = self.model_name or "gemini-2.5-pro"
         if model_name == 'gemini': model_name = "gemini-2.5-pro"
+        provider_name = self._get_provider_name()
+
+        # Intentar caché primero
+        if self.cache:
+            cached = self.cache.get(prompt, provider_name, model_name)
+            if cached:
+                logger.info(f"[{provider_name}] Contenido obtenido del caché (modelo={model_name})")
+                return cached
 
         generation_config = {
             "temperature": kwargs.get("temperature", 0.7),
@@ -146,6 +276,7 @@ class GeminiProvider(LLMProvider):
             "response_mime_type": "text/plain",
         }
 
+        # Generar respuesta
         try:
             model_instance = self.genai.GenerativeModel(
                 model_name=model_name,
@@ -155,54 +286,81 @@ class GeminiProvider(LLMProvider):
                 system_instruction=system_prompt
             )
             response = model_instance.generate_content(prompt)
-            return response.text
+            content = response.text
+            logger.info(f"[{provider_name}] Contenido generado exitosamente (modelo={model_name}, longitud={len(content)})")
+
+            # Guardar en caché
+            if self.cache:
+                metadata = {
+                    'provider': provider_name,
+                    'model': model_name,
+                    'temperature': kwargs.get("temperature", 0.7),
+                    'max_tokens': kwargs.get("max_tokens", 8192)
+                }
+                self.cache.put(prompt, provider_name, model_name, content, metadata=metadata)
+
+            return content
         except Exception as e:
-            logger.error(f"Error llamando a Gemini API: {e}")
+            logger.error(f"[{provider_name}] Error llamando a Gemini API: {e}")
             return None
 
 
-class LocalProvider(LLMProvider):
+class LocalProvider(OpenAICompatibleProvider):
     """Proveedor para modelos locales (Ollama/LM Studio) vía OpenAI compatible API."""
 
-    def __init__(self, model_name: Optional[str] = None, base_url: str = "http://localhost:11434/v1"):
-        self.base_url = base_url
-        super().__init__(model_name)
+    def __init__(self, model_name: Optional[str] = None, base_url: str = "http://localhost:11434/v1", cache: Optional['LLMCache'] = None):
+        super().__init__(model_name, base_url=base_url, timeout=300.0, cache=cache)
 
     def _get_api_key(self) -> Optional[str]:
         return "not-needed"
 
     def _setup_client(self):
-        try:
-            from openai import OpenAI
-            self.client = OpenAI(
-                base_url=self.base_url,
-                api_key=self.api_key,
-                timeout=300.0
-            )
-        except ImportError:
-            logger.error("Biblioteca openai no instalada")
-            self.client = None
+        self._setup_openai_client(self.api_key, base_url=self.base_url, timeout=self.timeout)
 
     def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
-        if not self.client: return None
+        return self._openai_generate_content("Local", "llama3", system_prompt, prompt=prompt, **kwargs)
 
-        system_content = system_prompt or "Eres un experto en métodos matemáticos para física e ingeniería."
-        model = self.model_name or "llama3"
 
-        try:
-            response = self.client.chat.completions.create(
-                model=model,
-                messages=[
-                    {"role": "system", "content": system_content},
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=kwargs.get("temperature", 0.7),
-                max_tokens=kwargs.get("max_tokens", 2000)
-            )
-            return response.choices[0].message.content.strip()
-        except Exception as e:
-            logger.error(f"Error llamando a Local API: {e}")
-            return None
+class DeepSeekProvider(OpenAICompatibleProvider):
+    """Proveedor para DeepSeek (OpenAI-compatible)."""
+
+    def __init__(self, model_name: Optional[str] = None, cache: Optional['LLMCache'] = None):
+        super().__init__(model_name, base_url="https://api.deepseek.com", cache=cache)
+
+    def _get_api_key(self) -> Optional[str]:
+        key = os.getenv("DEEPSEEK_API_KEY")
+        if not key:
+            logger.warning("DEEPSEEK_API_KEY no encontrada")
+        return key
+
+    def _setup_client(self):
+        self._setup_openai_client(self.api_key, base_url=self.base_url)
+
+    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        return self._openai_generate_content("DeepSeek", "deepseek-chat", system_prompt, prompt=prompt, **kwargs)
+
+
+class GenericProvider(OpenAICompatibleProvider):
+    """Proveedor Genérico Compatible con OpenAI (Groq, Mistral, etc)."""
+
+    def __init__(self, model_name: Optional[str] = None, base_url: Optional[str] = None, cache: Optional['LLMCache'] = None):
+        super().__init__(model_name, base_url=base_url or os.getenv("GENERIC_BASE_URL"), cache=cache)
+
+    def _get_api_key(self) -> Optional[str]:
+        key = os.getenv("GENERIC_API_KEY")
+        if not key:
+            logger.warning("GENERIC_API_KEY no encontrada")
+        return key
+
+    def _setup_client(self):
+        if not self.base_url:
+            logger.warning("GENERIC_BASE_URL no definida")
+        self._setup_openai_client(self.api_key, base_url=self.base_url)
+
+    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        default_system_prompt = self.DEFAULT_SYSTEM_PROMPT
+        default_model = os.getenv("GENERIC_MODEL") or "gpt-3.5-turbo"
+        return self._openai_generate_content("Generic", default_model, system_prompt or default_system_prompt, prompt=prompt, **kwargs)
 
 
 def get_provider(provider_name: str, **kwargs) -> LLMProvider:
@@ -215,5 +373,9 @@ def get_provider(provider_name: str, **kwargs) -> LLMProvider:
         return GeminiProvider(**kwargs)
     elif provider_name == "local":
         return LocalProvider(**kwargs)
+    elif provider_name == "deepseek":
+        return DeepSeekProvider(**kwargs)
+    elif provider_name == "generic":
+        return GenericProvider(**kwargs)
     else:
         raise ValueError(f"Proveedor desconocido: {provider_name}")

evolutia/material_extractor.py

@@ -1,10 +1,11 @@
-"""
-Extractor de materiales didácticos.
-Lee y parsea archivos Markdown de lecturas, prácticas y tareas.
-"""
-from pathlib import Path
-from typing import Dict, List, Optional
-import logging
+"""
+Extractor de materiales didácticos.
+Lee y parsea archivos Markdown de lecturas, prácticas y tareas.
+"""
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+import logging
+import time
 
 try:
     from utils.markdown_parser import (
@@ -27,31 +28,43 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-class MaterialExtractor:
-    """Extrae ejercicios y soluciones de materiales didácticos."""
+class MaterialExtractor:
+    """Extrae ejercicios y soluciones de materiales didácticos."""
+
+    def __init__(self, base_path: Union[Path, str]):
+        """
+        Inicializa el extractor.
+
+        Args:
+            base_path: Ruta base del proyecto (donde están los directorios de temas)
+        """
+        self.base_path = Path(base_path)
+        self.exercises = []
+        self.solutions = []
+        # Caché de rutas de archivos válidos para evitar escaneos repetidos
+        self._file_cache: Dict[Path, Dict] = {}
+        # Timestamp del último escaneo
+        self._last_scan_timestamp: float = 0
+        # TTL del caché en segundos (5 minutos)
+        self._cache_ttl = 300
     
-    def __init__(self, base_path: Path):
-        """
-        Inicializa el extractor.
-        
-        Args:
-            base_path: Ruta base del proyecto (donde están los directorios de temas)
-        """
-        self.base_path = Path(base_path)
-        self.exercises = []
-        self.solutions = []
-    
-    def extract_from_file(self, file_path: Path) -> Dict:
-        """
-        Extrae ejercicios y soluciones de un archivo Markdown.
-        
-        Args:
-            file_path: Ruta al archivo
-            
-        Returns:
-            Diccionario con ejercicios y soluciones extraídos
-        """
-        try:
+    def extract_from_file(self, file_path: Path, use_cache: bool = True) -> Dict:
+        """
+        Extrae ejercicios y soluciones de un archivo Markdown.
+
+        Args:
+            file_path: Ruta al archivo
+            use_cache: Si True, usa el caché si es válido (default: True)
+
+        Returns:
+            Diccionario con ejercicios y soluciones extraídos
+        """
+        # Verificar caché primero
+        if use_cache and self._is_cache_valid(file_path):
+            logger.debug(f"[MaterialExtractor] Usando caché para {file_path.name}")
+            return self._file_cache[file_path]['data']
+
+        try:
             content = read_markdown_file(file_path)
             frontmatter, content_body = extract_frontmatter(content)
             
@@ -65,62 +78,81 @@ class MaterialExtractor:
                         exercise['include_path'],
                         file_path.parent
                     )
-                    if include_path.exists():
-                        exercise['resolved_content'] = read_markdown_file(include_path)
-                    else:
-                        logger.warning(f"Include no encontrado: {include_path}")
-                        exercise['resolved_content'] = exercise['content']
-                else:
-                    exercise['resolved_content'] = exercise['content']
-            
-            # Resolver includes de soluciones
-            for solution in solutions:
-                resolved_content_parts = []
-                for include_path_str in solution['include_paths']:
-                    include_path = resolve_include_path(
-                        include_path_str,
-                        file_path.parent
-                    )
-                    if include_path.exists():
-                        resolved_content_parts.append(read_markdown_file(include_path))
-                    else:
-                        logger.warning(f"Include no encontrado: {include_path}")
-                
-                if resolved_content_parts:
-                    solution['resolved_content'] = '\n\n---\n\n'.join(resolved_content_parts)
-                else:
-                    solution['resolved_content'] = solution['content']
-            
-            return {
-                'file_path': file_path,
-                'frontmatter': frontmatter,
-                'exercises': exercises,
-                'solutions': solutions,
-                'content_body': content_body  # Exponer contenido para indexación de lecturas
-            }
-        except Exception as e:
-            logger.error(f"Error extrayendo de {file_path}: {e}")
-            return {
-                'file_path': file_path,
-                'frontmatter': {},
-                'exercises': [],
-                'solutions': []
-            }
-    
-    def extract_from_directory(self, directory: Path, pattern: str = "*.md") -> List[Dict]:
-        """
-        Extrae materiales de todos los archivos .md en un directorio.
-        
-        Args:
-            directory: Directorio a procesar
-            pattern: Patrón de búsqueda de archivos
+                    if include_path.exists():
+                        exercise['resolved_content'] = read_markdown_file(include_path)
+                    else:
+                        logger.warning(f"[MaterialExtractor] Include no encontrado en ejercicio: {include_path} (archivo: {file_path})")
+                        exercise['resolved_content'] = exercise['content']
+                else:
+                    exercise['resolved_content'] = exercise['content']
+
+            # Resolver includes de soluciones
+            for solution in solutions:
+                resolved_content_parts = []
+                for include_path_str in solution['include_paths']:
+                    include_path = resolve_include_path(
+                        include_path_str,
+                        file_path.parent
+                    )
+                    if include_path.exists():
+                        resolved_content_parts.append(read_markdown_file(include_path))
+                    else:
+                        logger.warning(f"[MaterialExtractor] Include no encontrado en solución: {include_path} (archivo: {file_path})")
+
+                if resolved_content_parts:
+                    solution['resolved_content'] = '\n\n---\n\n'.join(resolved_content_parts)
+                else:
+                    solution['resolved_content'] = solution['content']
             
-        Returns:
-            Lista de diccionarios con materiales extraídos
-        """
-        directory = Path(directory)
-        if not directory.exists():
-            logger.warning(f"Directorio no existe: {directory}")
+            return {
+                'file_path': file_path,
+                'frontmatter': frontmatter,
+                'exercises': exercises,
+                'solutions': solutions,
+                'content_body': content_body  # Exponer contenido para indexación de lecturas
+            }
+
+            # Guardar en caché
+            if use_cache:
+                self._file_cache[file_path] = {
+                    'data': result,
+                    'timestamp': file_path.stat().st_mtime
+                }
+                self._last_scan_timestamp = max(self._last_scan_timestamp, file_path.stat().st_mtime)
+
+            return result
+        except Exception as e:
+            logger.error(f"[MaterialExtractor] Error extrayendo de {file_path}: {e}")
+            error_result = {
+                'file_path': file_path,
+                'frontmatter': {},
+                'exercises': [],
+                'solutions': []
+            }
+
+            # Guardar incluso errores en caché para evitar reintentos fallidos
+            if use_cache:
+                self._file_cache[file_path] = {
+                    'data': error_result,
+                    'timestamp': time.time()  # Usar tiempo actual para archivos que no existen
+                }
+
+            return error_result
+
+    def extract_from_directory(self, directory: Path, pattern: str = "*.md") -> List[Dict]:
+        """
+        Extrae materiales de todos los archivos .md en un directorio.
+
+        Args:
+            directory: Directorio a procesar
+            pattern: Patrón de búsqueda de archivos
+
+        Returns:
+            Lista de diccionarios con materiales extraídos
+        """
+        directory = Path(directory)
+        if not directory.exists():
+            logger.warning(f"[MaterialExtractor] Directorio no existe: {directory}")
             return []
         
         materials = []
@@ -233,5 +265,51 @@ class MaterialExtractor:
                 }
                 all_exercises.append(exercise_data)
         
-        return all_exercises
-
+        return all_exercises
+
+    def clear_cache(self):
+        """Limpia el caché de archivos."""
+        self._file_cache.clear()
+        self._last_scan_timestamp = 0
+        logger.debug("[MaterialExtractor] Caché de archivos limpiado")
+
+    def _is_cache_valid(self, file_path: Path) -> bool:
+        """
+        Verifica si el caché para un archivo es válido.
+
+        Args:
+            file_path: Ruta del archivo a verificar
+
+        Returns:
+            True si el caché es válido, False si necesita recacheo
+        """
+        if file_path not in self._file_cache:
+            return False
+
+        # Verificar si el archivo fue modificado
+        try:
+            cache_entry = self._file_cache[file_path]
+            file_mtime = file_path.stat().st_mtime
+
+            # Usar el timestamp de escaneo más reciente para verificar
+            if file_mtime > self._last_scan_timestamp:
+                return False
+
+            return True
+        except (OSError, KeyError):
+            return False
+
+    def get_cache_stats(self) -> Dict:
+        """
+        Obtiene estadísticas del caché de archivos.
+
+        Returns:
+            Diccionario con estadísticas del caché
+        """
+        return {
+            'cached_files': len(self._file_cache),
+            'last_scan_timestamp': self._last_scan_timestamp,
+            'cache_ttl': self._cache_ttl
+        }
+
+