evolutia 0.1.0__py3-none-any.whl

evolutia/llm_providers.py

@@ -0,0 +1,217 @@
+"""
+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
+
+logger = logging.getLogger(__name__)
+
+class LLMProvider(ABC):
+    """Clase base abstracta para proveedores de LLM."""
+
+    def __init__(self, model_name: Optional[str] = None):
+        self.model_name = model_name
+        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
+
+    @abstractmethod
+    def _get_api_key(self) -> Optional[str]:
+        """Obtiene la API key de las variables de entorno."""
+        pass
+
+    @abstractmethod
+    def _setup_client(self):
+        """Configura el cliente de la API."""
+        pass
+
+    @abstractmethod
+    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        """Genera contenido a partir de un prompt."""
+        pass
+
+
+class OpenAIProvider(LLMProvider):
+    """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):
+        try:
+            from openai import OpenAI
+            self.client = OpenAI(api_key=self.api_key)
+        except ImportError:
+            logger.error("Biblioteca openai no instalada. Instala con: pip install openai")
+            self.client = 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"
+        
+        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 OpenAI API: {e}")
+            return None
+
+
+class AnthropicProvider(LLMProvider):
+    """Proveedor para Anthropic (Claude)."""
+
+    def _get_api_key(self) -> Optional[str]:
+        key = os.getenv("ANTHROPIC_API_KEY")
+        if not key:
+            logger.warning("ANTHROPIC_API_KEY no encontrada")
+        return key
+
+    def _setup_client(self):
+        try:
+            import anthropic
+            self.client = anthropic.Anthropic(api_key=self.api_key)
+        except ImportError:
+            logger.error("Biblioteca anthropic no instalada. Instala con: pip install anthropic")
+            self.client = 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 "claude-3-opus-20240229"
+
+        try:
+            message = self.client.messages.create(
+                model=model,
+                max_tokens=kwargs.get("max_tokens", 2000),
+                temperature=kwargs.get("temperature", 0.7),
+                system=system_content,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return message.content[0].text.strip()
+        except Exception as e:
+            logger.error(f"Error llamando a Anthropic API: {e}")
+            return None
+
+
+class GeminiProvider(LLMProvider):
+    """Proveedor para Google Gemini."""
+
+    def _get_api_key(self) -> Optional[str]:
+        key = os.getenv("GOOGLE_API_KEY")
+        if not key:
+            logger.warning("GOOGLE_API_KEY no encontrada")
+        return key
+
+    def _setup_client(self):
+        try:
+            import google.generativeai as genai
+            genai.configure(api_key=self.api_key)
+            self.genai = genai
+        except ImportError:
+            logger.error("Biblioteca google-generativeai no instalada")
+            self.genai = None
+
+    def generate_content(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> Optional[str]:
+        if not self.genai: return None
+
+        model_name = self.model_name or "gemini-2.5-pro"
+        if model_name == 'gemini': model_name = "gemini-2.5-pro"
+
+        generation_config = {
+            "temperature": kwargs.get("temperature", 0.7),
+            "top_p": 0.95,
+            "top_k": 64,
+            "max_output_tokens": kwargs.get("max_tokens", 8192),
+            "response_mime_type": "text/plain",
+        }
+
+        try:
+            model_instance = self.genai.GenerativeModel(
+                model_name=model_name,
+                generation_config=generation_config,
+                # System instructions can be passed to model if supported, 
+                # or prepended to prompt. Gemini 1.5 supports system_instruction arg.
+                system_instruction=system_prompt
+            )
+            response = model_instance.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            logger.error(f"Error llamando a Gemini API: {e}")
+            return None
+
+
+class LocalProvider(LLMProvider):
+    """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 _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
+
+    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 "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
+
+
+def get_provider(provider_name: str, **kwargs) -> LLMProvider:
+    """Factory method para obtener un proveedor."""
+    if provider_name == "openai":
+        return OpenAIProvider(**kwargs)
+    elif provider_name == "anthropic":
+        return AnthropicProvider(**kwargs)
+    elif provider_name == "gemini":
+        return GeminiProvider(**kwargs)
+    elif provider_name == "local":
+        return LocalProvider(**kwargs)
+    else:
+        raise ValueError(f"Proveedor desconocido: {provider_name}")

evolutia/material_extractor.py

@@ -0,0 +1,237 @@
+"""
+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
+
+try:
+    from utils.markdown_parser import (
+        read_markdown_file,
+        extract_frontmatter,
+        extract_exercise_blocks,
+        extract_solution_blocks,
+        resolve_include_path
+    )
+except ImportError:
+    from .utils.markdown_parser import (
+        read_markdown_file,
+        extract_frontmatter,
+        extract_exercise_blocks,
+        extract_solution_blocks,
+        resolve_include_path
+    )
+
+
+logger = logging.getLogger(__name__)
+
+
+class MaterialExtractor:
+    """Extrae ejercicios y soluciones de materiales didácticos."""
+    
+    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:
+            content = read_markdown_file(file_path)
+            frontmatter, content_body = extract_frontmatter(content)
+            
+            exercises = extract_exercise_blocks(content_body)
+            solutions = extract_solution_blocks(content_body)
+            
+            # Resolver includes de ejercicios
+            for exercise in exercises:
+                if exercise['include_path']:
+                    include_path = resolve_include_path(
+                        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
+            
+        Returns:
+            Lista de diccionarios con materiales extraídos
+        """
+        directory = Path(directory)
+        if not directory.exists():
+            logger.warning(f"Directorio no existe: {directory}")
+            return []
+        
+        materials = []
+        for md_file in directory.rglob(pattern):
+            # Ignorar archivos en _build y otros directorios temporales
+            if '_build' in md_file.parts or 'node_modules' in md_file.parts:
+                continue
+            
+            material = self.extract_from_file(md_file)
+            # Incluirlos si tienen ejercicios/soluciones O si parecen ser materiales de lectura/teoría
+            if material['exercises'] or material['solutions'] or 'lectura' in md_file.name.lower() or 'teoria' in md_file.name.lower():
+                materials.append(material)
+        
+        return materials
+    
+    def extract_by_topic(self, topic: str) -> List[Dict]:
+        """
+        Extrae materiales de un tema específico.
+        
+        Busca en:
+        - {topic}/semana*_practica.md
+        - {topic}/semana*_lectura.md
+        - tareas/tarea*/tarea*.md
+        
+        Args:
+            topic: Nombre del tema (ej: "analisis_vectorial")
+            
+        Returns:
+            Lista de materiales extraídos
+        """
+        materials = []
+        
+        # Buscar en directorio del tema
+        topic_dir = self.base_path / topic
+        if topic_dir.exists():
+            # Buscar prácticas
+            practice_files = list(topic_dir.glob("*practica*.md"))
+            for file in practice_files:
+                materials.append(self.extract_from_file(file))
+            
+            # Buscar lecturas (pueden tener ejercicios)
+            reading_files = list(topic_dir.glob("*lectura*.md"))
+            for file in reading_files:
+                materials.append(self.extract_from_file(file))
+        
+        # Buscar en tareas (pueden ser de múltiples temas)
+        tareas_dir = self.base_path / "tareas"
+        if tareas_dir.exists():
+            for tarea_dir in tareas_dir.iterdir():
+                if tarea_dir.is_dir():
+                    tarea_file = tarea_dir / f"{tarea_dir.name}.md"
+                    if tarea_file.exists():
+                        material = self.extract_from_file(tarea_file)
+                        # Filtrar por tema si es relevante (checking subject or tags)
+                        subject_match = material['frontmatter'].get('subject', '').lower().find(topic.lower()) != -1
+                        tags_match = any(topic.lower() in tag.lower() for tag in material['frontmatter'].get('tags', []))
+                        if subject_match or tags_match:
+                            materials.append(material)
+
+        # Buscar en examenes (pueden ser de múltiples temas) 
+        examenes_dir = self.base_path / "examenes"
+        if examenes_dir.exists():
+            for examen_dir in examenes_dir.iterdir():
+                if examen_dir.is_dir():
+                    examen_file = examen_dir / f"{examen_dir.name}.md"
+                    if examen_file.exists():
+                        material = self.extract_from_file(examen_file)
+                        # Filtrar por tema si es relevante
+                        subject_match = material['frontmatter'].get('subject', '').lower().find(topic.lower()) != -1
+                        tags_match = any(topic.lower() in tag.lower() for tag in material['frontmatter'].get('tags', []))
+                        
+                        # Si es examen, a veces no tiene subject especifico o tiene "Examen X".
+                        # Si no hay match explícito, tal vez incluirlo si no se encontraron otros materiales?
+                        # Para seguridad, requerimos algún match en subject, tags o keywords
+                        keywords_match = any(topic.lower() in kw.lower() for kw in material['frontmatter'].get('keywords', []))
+                        
+                        if subject_match or tags_match or keywords_match:
+                            materials.append(material)
+        
+        return materials
+    
+    def get_all_exercises(self, materials: List[Dict]) -> List[Dict]:
+        """
+        Obtiene todos los ejercicios de una lista de materiales.
+        
+        Args:
+            materials: Lista de materiales extraídos
+            
+        Returns:
+            Lista de ejercicios con sus metadatos
+        """
+        all_exercises = []
+        
+        for material in materials:
+            for exercise in material['exercises']:
+                # Buscar solución correspondiente
+                solution = None
+                for sol in material['solutions']:
+                    if sol['exercise_label'] == exercise['label']:
+                        solution = sol
+                        break
+                
+                exercise_data = {
+                    'label': exercise['label'],
+                    'content': exercise['resolved_content'],
+                    'source_file': material['file_path'],
+                    'frontmatter': material['frontmatter'],
+                    'solution': solution['resolved_content'] if solution else None,
+                    'solution_label': solution['label'] if solution else None
+                }
+                all_exercises.append(exercise_data)
+        
+        return all_exercises
+

evolutia/rag/__init__.py

@@ -0,0 +1,6 @@
+"""
+Sistema RAG (Retrieval-Augmented Generation) para generador de exámenes.
+"""
+
+__version__ = "1.0.0"
+

evolutia/rag/consistency_validator.py

@@ -0,0 +1,200 @@
+"""
+Consistency Validator: Valida consistencia usando RAG.
+"""
+import logging
+from typing import Dict, List, Optional
+
+try:
+    from complexity_validator import ComplexityValidator
+except ImportError:
+    try:
+        from ..complexity_validator import ComplexityValidator
+    except ImportError:
+        import sys
+        from pathlib import Path
+        sys.path.insert(0, str(Path(__file__).parent.parent))
+        from complexity_validator import ComplexityValidator
+
+try:
+    from rag.rag_retriever import RAGRetriever
+    from rag.context_enricher import ContextEnricher
+except ImportError:
+    try:
+        from .rag_retriever import RAGRetriever
+        from .context_enricher import ContextEnricher
+    except ImportError:
+        from rag_retriever import RAGRetriever
+        from context_enricher import ContextEnricher
+
+logger = logging.getLogger(__name__)
+
+
+class ConsistencyValidator(ComplexityValidator):
+    """Valida consistencia usando RAG además de validación de complejidad."""
+    
+    def __init__(self, retriever: RAGRetriever = None, context_enricher: ContextEnricher = None):
+        """
+        Inicializa el validador de consistencia.
+        
+        Args:
+            retriever: Instancia de RAGRetriever
+            context_enricher: Instancia de ContextEnricher
+        """
+        super().__init__()
+        self.retriever = retriever
+        self.context_enricher = context_enricher or ContextEnricher()
+    
+    def validate_consistency(self, variation_content: str, original_exercise: Dict,
+                           original_analysis: Dict) -> Dict:
+        """
+        Valida consistencia de la variación con ejercicios similares del curso.
+        
+        Args:
+            variation_content: Contenido de la variación generada
+            original_exercise: Ejercicio original
+            original_analysis: Análisis del ejercicio original
+            
+        Returns:
+            Diccionario con resultados de validación de consistencia
+        """
+        if not self.retriever:
+            return {
+                'is_consistent': True,
+                'reason': 'RAG no disponible, saltando validación de consistencia',
+                'similarity_scores': [],
+                'warnings': []
+            }
+        
+        try:
+            # Buscar ejercicios similares a la variación
+            similar_exercises = self.retriever.retrieve_similar_exercises(
+                variation_content,
+                exclude_label=original_exercise.get('label'),
+                top_k=5
+            )
+            
+            if not similar_exercises:
+                return {
+                    'is_consistent': True,
+                    'reason': 'No se encontraron ejercicios similares para comparar',
+                    'similarity_scores': [],
+                    'warnings': []
+                }
+            
+            # Analizar similitudes
+            similarity_scores = [ex.get('similarity', 0) for ex in similar_exercises]
+            avg_similarity = sum(similarity_scores) / len(similarity_scores) if similarity_scores else 0
+            
+            # Verificar consistencia de complejidad
+            complexity_warnings = []
+            variation_complexity = original_analysis.get('total_complexity', 0) * 1.2  # Estimación
+            
+            for exercise in similar_exercises[:3]:  # Top 3
+                ex_complexity = float(exercise.get('metadata', {}).get('complexity', 0))
+                if ex_complexity > 0:
+                    diff = abs(variation_complexity - ex_complexity) / ex_complexity
+                    if diff > 0.5:  # Más del 50% de diferencia
+                        complexity_warnings.append(
+                            f"Complejidad muy diferente de ejercicio similar "
+                            f"(variación: {variation_complexity:.2f}, similar: {ex_complexity:.2f})"
+                        )
+            
+            # Verificar consistencia de conceptos
+            concept_warnings = []
+            original_concepts = set(original_analysis.get('concepts', []))
+            
+            for exercise in similar_exercises[:3]:
+                ex_concepts = set(
+                    exercise.get('metadata', {}).get('concepts', '').split(',')
+                    if exercise.get('metadata', {}).get('concepts') else []
+                )
+                ex_concepts = {c.strip() for c in ex_concepts if c.strip()}
+                
+                # Verificar si hay conceptos muy diferentes
+                if ex_concepts and original_concepts:
+                    overlap = len(original_concepts & ex_concepts) / len(original_concepts | ex_concepts)
+                    if overlap < 0.3:  # Menos del 30% de overlap
+                        concept_warnings.append(
+                            f"Conceptos muy diferentes de ejercicios similares "
+                            f"(overlap: {overlap:.2f})"
+                        )
+            
+            # Determinar si es consistente
+            is_consistent = (
+                avg_similarity >= 0.5 and  # Al menos 50% de similitud promedio
+                len(complexity_warnings) < 2 and  # No demasiadas advertencias de complejidad
+                len(concept_warnings) < 2  # No demasiadas advertencias de conceptos
+            )
+            
+            return {
+                'is_consistent': is_consistent,
+                'avg_similarity': avg_similarity,
+                'similarity_scores': similarity_scores,
+                'similar_exercises_count': len(similar_exercises),
+                'complexity_warnings': complexity_warnings,
+                'concept_warnings': concept_warnings,
+                'warnings': complexity_warnings + concept_warnings
+            }
+        
+        except Exception as e:
+            logger.error(f"Error en validación de consistencia: {e}")
+            return {
+                'is_consistent': True,  # Por defecto, asumir consistente si hay error
+                'reason': f'Error en validación: {str(e)}',
+                'similarity_scores': [],
+                'warnings': []
+            }
+    
+    def validate(self, original_exercise: Dict, original_analysis: Dict,
+                 variation: Dict) -> Dict:
+        """
+        Valida variación usando tanto complejidad como consistencia RAG.
+        
+        Args:
+            original_exercise: Ejercicio original
+            original_analysis: Análisis del ejercicio original
+            variation: Variación generada
+            
+        Returns:
+            Diccionario con validación completa
+        """
+        # Primero validar complejidad (método del padre)
+        complexity_validation = super().validate(
+            original_exercise,
+            original_analysis,
+            variation
+        )
+        
+        # Luego validar consistencia con RAG
+        variation_content = variation.get('variation_content', '')
+        consistency_validation = self.validate_consistency(
+            variation_content,
+            original_exercise,
+            original_analysis
+        )
+        
+        # Combinar resultados
+        combined_validation = {
+            **complexity_validation,
+            'consistency': consistency_validation,
+            'is_valid': (
+                complexity_validation.get('is_valid', False) and
+                consistency_validation.get('is_consistent', True)  # Consistencia es opcional
+            )
+        }
+        
+        # Agregar advertencias de consistencia
+        if consistency_validation.get('warnings'):
+            combined_validation['warnings'].extend(
+                [f"Consistencia: {w}" for w in consistency_validation['warnings']]
+            )
+        
+        # Agregar información de similitud
+        if consistency_validation.get('avg_similarity'):
+            combined_validation['rag_avg_similarity'] = consistency_validation['avg_similarity']
+            combined_validation['improvements'].append(
+                f"Similitud promedio con ejercicios del curso: {consistency_validation['avg_similarity']:.2f}"
+            )
+        
+        return combined_validation
+