evolutia 0.1.0__py3-none-any.whl

evolutia/__init__.py

@@ -0,0 +1,5 @@
+from .evolutia_engine import EvolutiaEngine
+from .variation_generator import VariationGenerator
+from .llm_providers import LLMProvider, get_provider
+
+__version__ = "0.1.0"

evolutia/complexity_validator.py

@@ -0,0 +1,179 @@
+"""
+Validador de complejidad.
+Verifica que las variaciones generadas sean más complejas que los originales.
+"""
+import logging
+from typing import Dict
+
+from .exercise_analyzer import ExerciseAnalyzer
+from .utils.math_extractor import extract_math_expressions, estimate_complexity
+
+
+logger = logging.getLogger(__name__)
+
+
+class ComplexityValidator:
+    """Valida que las variaciones sean más complejas que los originales."""
+    
+    def __init__(self):
+        """Inicializa el validador."""
+        self.analyzer = ExerciseAnalyzer()
+    
+    def validate(self, original_exercise: Dict, original_analysis: Dict, 
+                 variation: Dict) -> Dict:
+        """
+        Valida que la variación sea más compleja que el original.
+        
+        Args:
+            original_exercise: Ejercicio original
+            original_analysis: Análisis del ejercicio original
+            variation: Variación generada (debe tener 'variation_content')
+        
+        Returns:
+            Diccionario con resultado de validación:
+            - 'is_valid': bool
+            - 'variation_analysis': análisis de la variación
+            - 'improvements': lista de mejoras detectadas
+            - 'warnings': lista de advertencias
+        """
+        variation_content = variation.get('variation_content', '')
+        variation_solution = variation.get('variation_solution', '')
+        
+        if not variation_content:
+            return {
+                'is_valid': False,
+                'reason': 'Variación sin contenido',
+                'variation_analysis': None,
+                'improvements': [],
+                'warnings': ['Variación generada está vacía']
+            }
+        
+        # Analizar la variación
+        variation_exercise = {
+            'content': variation_content,
+            'solution': variation_solution
+        }
+        variation_analysis = self.analyzer.analyze(variation_exercise)
+        
+        # Comparar métricas
+        improvements = []
+        warnings = []
+        
+        # Comparar complejidad total
+        original_complexity = original_analysis.get('total_complexity', 0)
+        variation_complexity = variation_analysis.get('total_complexity', 0)
+        
+        if variation_complexity > original_complexity * 1.1:  # Al menos 10% más complejo
+            improvements.append(
+                f"Complejidad total aumentó de {original_complexity:.2f} a {variation_complexity:.2f}"
+            )
+        elif variation_complexity < original_complexity:
+            warnings.append(
+                f"Complejidad total disminuyó de {original_complexity:.2f} a {variation_complexity:.2f}"
+            )
+        
+        # Comparar número de pasos
+        original_steps = original_analysis.get('solution_steps', 0)
+        variation_steps = variation_analysis.get('solution_steps', 0)
+        
+        if variation_steps > original_steps:
+            improvements.append(
+                f"Número de pasos aumentó de {original_steps} a {variation_steps}"
+            )
+        elif variation_steps < original_steps and original_steps > 0:
+            warnings.append(
+                f"Número de pasos disminuyó de {original_steps} a {variation_steps}"
+            )
+        
+        # Comparar número de variables
+        original_vars = original_analysis.get('num_variables', 0)
+        variation_vars = variation_analysis.get('num_variables', 0)
+        
+        if variation_vars > original_vars:
+            improvements.append(
+                f"Número de variables aumentó de {original_vars} a {variation_vars}"
+            )
+        
+        # Comparar número de conceptos
+        original_concepts = original_analysis.get('num_concepts', 0)
+        variation_concepts = variation_analysis.get('num_concepts', 0)
+        
+        if variation_concepts > original_concepts:
+            improvements.append(
+                f"Número de conceptos aumentó de {original_concepts} a {variation_concepts}"
+            )
+        
+        # Comparar complejidad matemática
+        original_math = original_analysis.get('math_complexity', 0)
+        variation_math = variation_analysis.get('math_complexity', 0)
+        
+        if variation_math > original_math * 1.1:
+            improvements.append(
+                f"Complejidad matemática aumentó de {original_math:.2f} a {variation_math:.2f}"
+            )
+        elif variation_math < original_math:
+            warnings.append(
+                f"Complejidad matemática disminuyó de {original_math:.2f} a {variation_math:.2f}"
+            )
+        
+        # Comparar operaciones
+        original_ops = original_analysis.get('operations', {})
+        variation_ops = variation_analysis.get('operations', {})
+        
+        for op_type in ['integrals', 'derivatives', 'sums', 'vectors', 'matrices']:
+            orig_count = original_ops.get(op_type, 0)
+            var_count = variation_ops.get(op_type, 0)
+            if var_count > orig_count:
+                improvements.append(
+                    f"Operaciones de {op_type} aumentaron de {orig_count} a {var_count}"
+                )
+        
+        # Determinar si es válida
+        # Requisitos mínimos:
+        # 1. Complejidad total debe ser mayor
+        # 2. Al menos una métrica debe mejorar significativamente
+        is_valid = (
+            variation_complexity > original_complexity and
+            len(improvements) >= 2
+        )
+        
+        if not is_valid and len(warnings) > 0:
+            warnings.append("La variación no cumple con los requisitos mínimos de complejidad")
+        
+        return {
+            'is_valid': is_valid,
+            'variation_analysis': variation_analysis,
+            'improvements': improvements,
+            'warnings': warnings,
+            'original_complexity': original_complexity,
+            'variation_complexity': variation_complexity,
+            'complexity_increase': variation_complexity - original_complexity,
+            'complexity_increase_percent': (
+                (variation_complexity - original_complexity) / original_complexity * 100
+                if original_complexity > 0 else 0
+            )
+        }
+    
+    def validate_batch(self, exercises_and_variations: list) -> list:
+        """
+        Valida un lote de variaciones.
+        
+        Args:
+            exercises_and_variations: Lista de tuplas (ejercicio_original, análisis_original, variación)
+        
+        Returns:
+            Lista de resultados de validación
+        """
+        results = []
+        
+        for original_exercise, original_analysis, variation in exercises_and_variations:
+            result = self.validate(original_exercise, original_analysis, variation)
+            results.append(result)
+            
+            if result['is_valid']:
+                logger.info(f"Variación válida: {len(result['improvements'])} mejoras detectadas")
+            else:
+                logger.warning(f"Variación inválida: {result.get('reason', 'Complejidad insuficiente')}")
+        
+        return results
+

evolutia/config_manager.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Gestor de configuración automática.
+Genera config.yaml basado en la estructura del proyecto y metadatos de archivos.
+"""
+import yaml
+import logging
+from pathlib import Path
+from typing import Dict, List, Set, Any
+import sys
+import json
+try:
+    import jsonschema
+    JSONSCHEMA_AVAILABLE = True
+except ImportError:
+    JSONSCHEMA_AVAILABLE = False
+
+# Configurar logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Directorios a excluir de la búsqueda de temas
+EXCLUDED_DIRS = {
+    'evolutia', 
+    #'examenes', 
+    #'tareas', 
+    'proyecto', 
+    '_build', 
+    '.git', 
+    '__pycache__',
+    '.ipynb_checkpoints',
+    'images',
+    'static',
+    'storage',
+    'thumbnails',
+    'config'
+}
+
+class ConfigManager:
+    def __init__(self, base_path: Path, config_path: Path = None):
+        self.base_path = Path(base_path)
+        
+        if config_path:
+            self.config_path = Path(config_path)
+        else:
+            # Intentar encontrar evolutia_config.yaml en la raíz
+            root_config = self.base_path / 'evolutia_config.yaml'
+            if root_config.exists():
+                self.config_path = root_config
+            else:
+               # Default interno: evolutia/config/config.yaml
+               # self.base_path suele ser root
+               # Si base_path es root, la config está en root/evolutia/config/config.yaml
+               self.config_path = self.base_path / 'evolutia' / 'config' / 'config.yaml'
+        
+        logger.info(f"Usando archivo de configuración: {self.config_path}")
+
+    def validate_config(self, config_data: Dict[str, Any]) -> bool:
+        """Valida la configuración contra el esquema JSON."""
+        if not JSONSCHEMA_AVAILABLE:
+            logger.warning("jsonschema no instalado, omitiendo validación de esquema.")
+            return True
+
+        # Buscar schema
+        # Intentar rutas relativas comunes
+        schema_path = Path(__file__).parent / 'schemas' / 'config.schema.json'
+        
+        if not schema_path.exists():
+             logger.warning(f"No se encontró esquema en {schema_path}, omitiendo validación.")
+             return True
+
+        try:
+            with open(schema_path, 'r', encoding='utf-8') as f:
+                schema = json.load(f)
+            
+            jsonschema.validate(instance=config_data, schema=schema)
+            logger.info("Configuración válida según esquema.")
+            return True
+        except jsonschema.exceptions.ValidationError as e:
+            logger.error(f"Error de validación de configuración: {e.message}")
+            logger.error(f"Ruta del error: {' -> '.join([str(p) for p in e.path])}")
+            return False
+        except Exception as e:
+            logger.error(f"Error inesperado validando esquema: {e}")
+            return False
+        
+    def load_current_config(self) -> Dict[str, Any]:
+        """Carga la configuración actual si existe."""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    config = yaml.safe_load(f) or {}
+                    # Validate on load
+                    if config:
+                        self.validate_config(config)
+                    return config
+            except Exception as e:
+                logger.error(f"Error leyendo config actual: {e}")
+                return {}
+        return {}
+
+    def discover_topics(self) -> List[str]:
+        """Descubre directorios de temas basados en la existencia de archivos .md."""
+        topics = []
+        for p in self.base_path.iterdir():
+            if p.is_dir() and p.name not in EXCLUDED_DIRS and not p.name.startswith('.'):
+                # Verificar si contiene archivos markdown relevantes (lecturas o prácticas)
+                md_files = list(p.glob("*.md"))
+                if md_files:
+                    topics.append(p.name)
+        return sorted(topics)
+
+    def extract_keywords_from_topic(self, topic: str) -> List[str]:
+        """Extrae keywords de los archivos del tema."""
+        topic_dir = self.base_path / topic
+        keywords_set: Set[str] = set()
+        
+        # Buscar en todos los md, pero priorizar lecturas
+        for md_file in topic_dir.glob("*.md"):
+            try:
+                content = md_file.read_text(encoding='utf-8')
+                # Extracción simple de frontmatter yaml
+                if content.startswith('---'):
+                    end_fm = content.find('---', 3)
+                    if end_fm != -1:
+                        fm_text = content[3:end_fm]
+                        fm = yaml.safe_load(fm_text)
+                        if fm and 'keywords' in fm:
+                            kw = fm['keywords']
+                            if isinstance(kw, list):
+                                keywords_set.update(kw)
+                            elif isinstance(kw, str):
+                                keywords_set.add(kw)
+            except Exception as e:
+                logger.warning(f"No se pudo leer keywords de {md_file}: {e}")
+                
+        return sorted(list(keywords_set))
+
+    def update_config(self):
+        """Actualiza el archivo de configuración."""
+        current_config = self.load_current_config()
+        
+        # Descubrir temas
+        topics = self.discover_topics()
+        logger.info(f"Temas encontrados: {topics}")
+        
+        # Extraer keywords por tema
+        topic_keywords = {}
+        for topic in topics:
+            kws = self.extract_keywords_from_topic(topic)
+            if kws:
+                topic_keywords[topic] = kws
+                logger.info(f"Keywords para {topic}: {len(kws)}")
+            else:
+                logger.warning(f"No se encontraron keywords para {topic}")
+
+        # Estructura base si no existe
+        if 'paths' not in current_config:
+            current_config['paths'] = {'base_path': '..'}
+        
+        if 'exam' not in current_config:
+            current_config['exam'] = {
+                'default': {
+                    'subject': "IF3602 - II semestre 2025",
+                    'points_per_exercise': 25,
+                    'duration_hours': 2.0
+                }
+            }
+            
+        # Actualizar valores dinámicos
+        current_config['paths']['materials_directories'] = topics
+        
+        if 'keywords' not in current_config['exam']:
+            current_config['exam']['keywords'] = {}
+            
+        # Mezclar keywords existentes con nuevas (priorizando las extraídas si se prefiere, o haciendo merge)
+        # Aquí reemplazamos para reflejar el estado actual del proyecto
+        current_config['exam']['keywords'] = topic_keywords
+
+        # Guardar configuración
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, 'w', encoding='utf-8') as f:
+            yaml.dump(current_config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+            
+        logger.info(f"Configuración actualizada en {self.config_path}")
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Gestor de configuración automática de Evolutia')
+    parser.add_argument('--config', type=str, help='Ruta al archivo de configuración a actualizar')
+    parser.add_argument('--base_path', type=str, default='.', help='Ruta base del proyecto')
+    args = parser.parse_args()
+
+    base_path = Path(args.base_path).resolve()
+    # Si estamos ejecutando desde evolutia (y no se dio base_path explícito), subir un nivel
+    if args.base_path == '.' and base_path.name == 'evolutia':
+        base_path = base_path.parent
+        
+    config_path = Path(args.config) if args.config else None
+        
+    manager = ConfigManager(base_path, config_path)
+    manager.update_config()
+
+if __name__ == '__main__':
+    main()

evolutia/evolutia_engine.py

@@ -0,0 +1,284 @@
+"""
+Motor principal de EvoluIA.
+Encapsula la lógica de orquestación, extracción, análisis y generación paralela.
+"""
+import logging
+import random
+import concurrent.futures
+import time
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple, Any
+from tqdm import tqdm
+
+# Imports from internal modules
+from .material_extractor import MaterialExtractor
+from .exercise_analyzer import ExerciseAnalyzer
+from .variation_generator import VariationGenerator
+from .complexity_validator import ComplexityValidator
+from .exam_generator import ExamGenerator
+from .config_manager import ConfigManager
+
+# Conditional RAG imports
+try:
+    from rag.rag_manager import RAGManager
+    from rag.enhanced_variation_generator import EnhancedVariationGenerator
+    from rag.consistency_validator import ConsistencyValidator
+    RAG_AVAILABLE = True
+except ImportError:
+    RAG_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+class EvolutiaEngine:
+    """
+    Motor central que coordina el flujo de trabajo de EvolutIA.
+    """
+
+    def __init__(self, base_path: Path, config_path: Optional[Path] = None):
+        self.base_path = base_path
+        self.config_path = config_path
+        self.rag_manager = None
+        
+        # Load configuration manager
+        self.config_manager = ConfigManager(base_path, config_path)
+        self.full_config = self.config_manager.load_current_config()
+
+    def initialize_rag(self, force_reindex: bool = False) -> bool:
+        """Inicializa el subsistema RAG si está disponible."""
+        if not RAG_AVAILABLE:
+            logger.error("RAG solicitado pero no disponible. Instala dependencias.")
+            return False
+            
+        try:
+            self.rag_manager = RAGManager(config_path=self.config_path, base_path=self.base_path)
+            self.rag_manager.initialize(force_reindex=force_reindex)
+            return True
+        except Exception as e:
+            logger.error(f"Error inicializando RAG: {e}")
+            return False
+
+    def get_api_config(self, provider: str) -> Dict[str, Any]:
+        """Obtiene la configuración específica para una API."""
+        return self.full_config.get('api', {}).get(provider, {})
+
+    def extract_materials_and_exercises(self, topics: List[str], label_filter: Optional[List[str]] = None) -> Tuple[List[Dict], List[Dict]]:
+        """
+        Paso 1 & 2: Extrae materiales y lista todos los ejercicios disponibles.
+        """
+        logger.info("Paso 1: Extrayendo materiales didácticos...")
+        extractor = MaterialExtractor(self.base_path)
+        materials = []
+
+        # 1. Extract by topic
+        if topics:
+            for topic in topics:
+                topic_materials = extractor.extract_by_topic(topic)
+                if topic_materials:
+                    materials.extend(topic_materials)
+                else:
+                    logger.warning(f"No se encontraron materiales para el tema: {topic}")
+        
+        # 2. Fallback: Search all if no materials found yet or topics were empty (e.g., list mode)
+        if not materials:
+            logger.info("Buscando en todos los directorios...")
+            for topic_dir in self.base_path.iterdir():
+                if topic_dir.is_dir() and topic_dir.name not in ['_build', 'evolutia', 'proyecto', '.git']:
+                    materials.extend(extractor.extract_from_directory(topic_dir))
+        
+        if not materials:
+            return [], []
+
+        logger.info(f"Encontrados {len(materials)} archivos con materiales")
+        
+        # Get exercises
+        logger.info("Paso 2: Obteniendo ejercicios...")
+        all_exercises = extractor.get_all_exercises(materials)
+        
+        # Filter by label if requested
+        if label_filter:
+            logger.info(f"Filtrando por labels: {label_filter}")
+            filtered = [ex for ex in all_exercises if ex.get('label') in label_filter]
+            if not filtered:
+                available = [ex.get('label') for ex in all_exercises if ex.get('label')]
+                logger.warning(f"No se encontraron ejercicios con los labels solicitados. Disponibles: {available[:10]}...")
+            all_exercises = filtered
+            
+        logger.info(f"Encontrados {len(all_exercises)} ejercicios")
+        return materials, all_exercises
+
+    def analyze_exercises(self, exercises: List[Dict]) -> List[Tuple[Dict, Dict]]:
+        """Paso 3: Analiza la complejidad de los ejercicios."""
+        logger.info("Paso 3: Analizando complejidad de ejercicios...")
+        analyzer = ExerciseAnalyzer()
+        exercises_with_analysis = []
+        
+        for exercise in exercises:
+            analysis = analyzer.analyze(exercise)
+            exercises_with_analysis.append((exercise, analysis))
+            
+        # Sort by total complexity descending
+        exercises_with_analysis.sort(key=lambda x: x[1]['total_complexity'], reverse=True)
+        return exercises_with_analysis
+
+    def _generate_single_variation(self, generator, validator, exercise_base, analysis, args) -> Optional[Dict]:
+        """Helper para generar una única variación (thread-safe logic)."""
+        attempt_count = 0
+        while attempt_count < 3:
+            try:
+                # Generate
+                if args.type == 'multiple_choice':
+                    variation = generator.generate_variation(
+                        exercise_base, 
+                        analysis, 
+                        exercise_type=args.type
+                    )
+                elif not args.no_generar_soluciones:
+                    variation = generator.generate_variation_with_solution(
+                        exercise_base, 
+                        analysis
+                    )
+                else:
+                    variation = generator.generate_variation(
+                        exercise_base, 
+                        analysis, 
+                        exercise_type=args.type
+                    )
+                
+                if not variation:
+                    attempt_count += 1
+                    continue
+
+                # Validate
+                if args.use_rag:
+                    validation = validator.validate(exercise_base, analysis, variation)
+                    is_valid = validation['is_valid']
+                else:
+                    validation = validator.validate(exercise_base, analysis, variation)
+                    is_valid = validation['is_valid']
+                
+                if is_valid:
+                    return variation
+                
+            except Exception as e:
+                logger.error(f"Error en hilo de generación: {e}")
+            
+            attempt_count += 1
+        return None
+
+    def _generate_creation_mode(self, generator, topic, tags, complexity, ex_type) -> Optional[Dict]:
+        """Helper para modo creación."""
+        try:
+            return generator.generate_new_exercise_from_topic(
+                topic, 
+                tags, 
+                difficulty=complexity,
+                exercise_type=ex_type
+            )
+        except Exception as e:
+            logger.error(f"Error en creación de ejercicio nuevo: {e}")
+            return None
+
+    def generate_variations_parallel(self, 
+                                   selected_exercises: List[Tuple[Dict, Dict]], 
+                                   args,
+                                   max_workers: int = 5) -> List[Dict]:
+        """
+        Paso 4: Genera variaciones en paralelo.
+        """
+        logger.info(f"Paso 4: Generando variaciones en paralelo (Workers: {max_workers})...")
+        
+        # Setup Generator
+        api_config = self.get_api_config(args.api)
+        
+        if (args.use_rag and self.rag_manager) or args.mode == 'creation':
+            retriever = self.rag_manager.get_retriever() if (args.use_rag and self.rag_manager) else None
+            generator = EnhancedVariationGenerator(api_provider=args.api, retriever=retriever)
+            validator = ConsistencyValidator(retriever=retriever) if retriever else ComplexityValidator()
+        else:
+            generator = VariationGenerator(api_provider=args.api)
+            validator = ComplexityValidator()
+
+        # Configure model
+        if args.api == 'local':
+            generator.base_url = api_config.get('base_url', "http://localhost:11434/v1")
+            generator.local_model = api_config.get('model', "llama3")
+        elif args.api in ['openai', 'anthropic']:
+            if 'model' in api_config:
+                generator.model_name = api_config['model']
+
+        # Determine tasks based on mode
+        tasks = []
+        
+        if args.mode == 'creation':
+            # Creation Mode Logic
+            for i in range(args.num_ejercicios):
+                current_topic = args.tema[i % len(args.tema)]
+                current_tags = [args.tags[i % len(args.tags)]] if args.tags else [current_topic]
+                
+                tasks.append({
+                    'func': self._generate_creation_mode,
+                    'args': (generator, current_topic, current_tags, args.complejidad, args.type)
+                })
+        else:
+            # Variation Mode Logic
+            
+            # If explicit lables, use exactly those
+            if args.label:
+                target_exercises = list(selected_exercises)
+            else:
+                 # Random selection to fill num_ejercicios
+                 target_exercises = []
+                 candidates = selected_exercises[:max(5, len(selected_exercises)//2)]
+                 for _ in range(args.num_ejercicios):
+                     if candidates:
+                        target_exercises.append(random.choice(candidates))
+
+            for ex_base, analysis in target_exercises:
+                tasks.append({
+                    'func': self._generate_single_variation,
+                    'args': (generator, validator, ex_base, analysis, args)
+                })
+
+        # Execute Parallel
+        valid_variations = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_task = {}
+            for t in tasks:
+                future = executor.submit(t['func'], *t['args'])
+                future_to_task[future] = t
+                # Stagger requests to avoid hitting rate limits instantly
+                time.sleep(1.0) 
+            
+            for future in tqdm(concurrent.futures.as_completed(future_to_task), total=len(tasks), desc="Generando"):
+                try:
+                    result = future.result()
+                    if result:
+                        valid_variations.append(result)
+                except Exception as e:
+                    logger.error(f"Excepción no manejada en worker: {e}")
+
+        logger.info(f"Generación completada. {len(valid_variations)} variaciones exitosas.")
+        return valid_variations
+
+    def generate_exam_files(self, variations: List[Dict], args, output_dir: Path, exam_number: int) -> bool:
+        """Paso 5: Genera los archivos finales del examen."""
+        logger.info("Paso 5: Generando archivos de examen...")
+        exam_gen = ExamGenerator(self.base_path)
+        
+        keywords = args.keywords or []
+        metadata = {
+            'model': args.api, # Simplified, internal details hidden
+            'provider': args.api,
+            'rag_enabled': args.use_rag,
+            'mode': args.mode,
+            'target_difficulty': args.complejidad
+        }
+        
+        return exam_gen.generate_exam(
+            variations,
+            exam_number,
+            output_dir,
+            args.subject,
+            keywords,
+            metadata=metadata
+        )