evolutia 0.1.0__py3-none-any.whl

evolutia/exam_generator.py

@@ -0,0 +1,328 @@
+"""
+Generador de archivos de examen en formato MyST/Markdown.
+Crea la estructura completa de archivos para un examen.
+"""
+import yaml
+from pathlib import Path
+from typing import Dict, List, Optional
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ExamGenerator:
+    """Genera archivos de examen en formato MyST/Markdown."""
+    
+    def __init__(self, base_path: Path):
+        """
+        Inicializa el generador.
+        
+        Args:
+            base_path: Ruta base del proyecto
+        """
+        self.base_path = Path(base_path)
+    
+    def generate_exam_frontmatter(self, exam_number: int, subject: str = "IF3602 - II semestre 2025",
+                                  tags: List[str] = None) -> str:
+        """
+        Genera el frontmatter YAML para un examen.
+        
+        Args:
+            exam_number: Número del examen
+            subject: Asignatura
+            tags: Lista de tags agregados
+        """
+        if tags is None:
+            tags = []
+        
+        frontmatter = {
+            'title': f'Examen  {exam_number}',
+            'description': f'Examen  {exam_number}',
+            'short_title': f'Examen  {exam_number}',
+            'author': ' ',
+            'tags': tags,
+            'subject': subject,
+            'date': datetime.now().strftime('%Y-%m-%d'),
+            'downloads': []
+        }
+        
+        # Convertir a YAML
+        yaml_str = yaml.dump(frontmatter, default_flow_style=False, allow_unicode=True, sort_keys=False)
+        return f"---\n{yaml_str}---\n\n"
+    
+    def generate_instructions_block(self) -> str:
+        """
+        Genera el bloque de instrucciones del examen.
+        
+        Returns:
+            String con el bloque de instrucciones en formato MyST
+        """
+        instructions = """:::{hint} Instrucciones
+:class: dropdown
+
+- Dispone de 2,0 horas para realizar el  examen, **individualmente**.
+- Debe mostrar la cédula de identidad o carnet universitario cuando se le solicite.
+- La prueba tiene un valor de 100 puntos.
+- Resuelva de forma razonada cada uno de los ejercicios.
+- Use esquemas y dibujos si lo considera necesario.
+- Debe incluir los cálculos y procedimientos que le llevan a su respuesta.
+- Debe resolver el examen en un cuaderno de examen u hojas debidamente engrapadas, utilizando lapicero de tinta de color azul o negra.
+- Si utiliza lápiz, corrector, lapicero de tinta roja o borrable, no se aceptarán reclamos.
+- Sólo se evaluará lo escrito en el cuaderno de examen.
+- Puede hacer uso únicamente de los materiales del curso; por medio de una computadora del aula C1-04. **No se permite el uso del teclado ni de herramientas de Inteligencia Artificial**.
+- Una vez que el examen haya comenzado, quienes lleguen dentro de los primeros 30 minutos podrán realizarlo, pero solo dispondrán del tiempo restante.
+- No se permitirá la salida del aula a ninguna persona estudiante durante los primeros 30 minutos de aplicación, salvo casos de fuerza mayor.
+- Debe apagar y guardar su celular, tableta, reloj o cualquier otro dispositivo inteligente durante el desarrollo de la prueba.
+
+:::
+"""
+        return instructions
+    
+    def generate_exercise_section(self, exercise_num: int, exam_num: int, 
+                                  points: int = 25) -> str:
+        """
+        Genera la sección de un ejercicio en el examen principal.
+        
+        Args:
+            exercise_num: Número del ejercicio
+            exam_num: Número del examen
+            points: Puntos del ejercicio
+        
+        Returns:
+            String con la sección del ejercicio
+        """
+        exercise_label = f"ex{exercise_num}_e{exam_num}"
+        solution_label = f"solucion-ex{exercise_num}_e{exam_num}"
+        exercise_file = f"./ex{exercise_num}_e{exam_num}.md"
+        solution_file = f"./solucion_ex{exercise_num}_e{exam_num}.md"
+        
+        section = f"""## Ejercicio {exercise_num} [{points} puntos]
+````{{exercise}} {exercise_num}
+:label: {exercise_label}
+
+```{{include}} {exercise_file}
+
+```
+
+````
+
+````{{solution}} {exercise_label}
+:label: {solution_label}
+:class: dropdown
+
+
+```{{include}} {solution_file}
+
+```
+````
+
+"""
+        return section
+    
+    def generate_exercise_file(self, exercise_content: str, exercise_num: int, 
+                               exam_num: int, metadata: Dict = None) -> str:
+        """
+        Genera el contenido de un archivo de ejercicio individual.
+        
+        Args:
+            exercise_content: Contenido del ejercicio
+            exercise_num: Número del ejercicio
+            exam_num: Número del examen
+            metadata: Metadatos opcionales (generator, model, date)
+        
+        Returns:
+            Contenido del archivo
+        """
+        content = ""
+        if metadata:
+            frontmatter = {
+                'generator': 'evolutia',
+                'source': 'ai_variation',
+                'date': datetime.now().isoformat()
+            }
+            frontmatter.update(metadata)
+            yaml_str = yaml.dump(frontmatter, default_flow_style=False, allow_unicode=True, sort_keys=False)
+            content += f"---\n{yaml_str}---\n\n"
+            
+        content += exercise_content.strip() + "\n"
+        return content
+    
+    def generate_solution_file(self, solution_content: str, exercise_num: int,
+                               exam_num: int, metadata: Dict = None) -> str:
+        """
+        Genera el contenido de un archivo de solución individual.
+        
+        Args:
+            solution_content: Contenido de la solución
+            exercise_num: Número del ejercicio
+            exam_num: Número del examen
+            metadata: Metadatos opcionales
+        
+        Returns:
+            Contenido del archivo
+        """
+        content = ""
+        if metadata:
+            frontmatter = {
+                'generator': 'evolutia',
+                'source': 'ai_solution',
+                'date': datetime.now().isoformat()
+            }
+            frontmatter.update(metadata)
+            yaml_str = yaml.dump(frontmatter, default_flow_style=False, allow_unicode=True, sort_keys=False)
+            content += f"---\n{yaml_str}---\n\n"
+            
+        content += solution_content.strip() + "\n"
+        return content
+    
+    def generate_exam(self, variations: List[Dict], exam_number: int,
+                      output_dir: Path, subject: str = "IF3602 - II semestre 2025",
+                      keywords: List[str] = None, metadata: Dict = None) -> bool:
+        """
+        Genera un examen completo con todas sus variaciones.
+        
+        Args:
+            variations: Lista de variaciones generadas (cada una debe tener
+                       'variation_content' y opcionalmente 'variation_solution')
+            exam_number: Número del examen
+            output_dir: Directorio donde crear los archivos
+            subject: Asignatura
+            keywords: Palabras clave
+            metadata: Metadatos generales para incluir en ejercicios (ej: model)
+        
+        Returns:
+            True si se generó exitosamente, False en caso contrario
+        """
+        try:
+            # Crear directorio si no existe
+            output_dir = Path(output_dir)
+            output_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Recolectar todos los tags de las variaciones
+            all_tags = set()
+            if keywords:
+                all_tags.update(keywords)
+            
+            for variation in variations:
+                original_frontmatter = variation.get('original_frontmatter', {})
+                if 'tags' in original_frontmatter and original_frontmatter['tags']:
+                    all_tags.update(original_frontmatter['tags'])
+            
+            # Generar archivo principal del examen
+            exam_content = self.generate_exam_frontmatter(exam_number, subject, list(all_tags))
+            exam_content += self.generate_instructions_block()
+            exam_content += "\n"
+            
+            # Agregar secciones de ejercicios
+            points_per_exercise = 100 // len(variations)
+            for i, variation in enumerate(variations, 1):
+                exam_content += self.generate_exercise_section(
+                    i, exam_number, points_per_exercise
+                )
+            
+            # Escribir archivo principal
+            exam_file = output_dir / f"examen{exam_number}.md"
+            with open(exam_file, 'w', encoding='utf-8') as f:
+                f.write(exam_content)
+            
+            logger.info(f"Archivo principal creado: {exam_file}")
+            
+            # Generar archivos individuales de ejercicios y soluciones
+            for i, variation in enumerate(variations, 1):
+                # Preparar metadatos específicos de esta variación
+                current_metadata = metadata.copy() if metadata else {}
+                original_frontmatter = variation.get('original_frontmatter', {})
+                
+                # Agregar tags y subject originales si existen
+                if 'tags' in original_frontmatter:
+                    current_metadata['tags'] = original_frontmatter['tags']
+                if 'subject' in original_frontmatter:
+                    current_metadata['original_subject'] = original_frontmatter['subject']
+                if 'complexity' in original_frontmatter:
+                    current_metadata['complexity'] = original_frontmatter['complexity']
+                
+                # Add original label for traceability
+                if 'original_label' in variation and variation['original_label']:
+                     current_metadata['based_on'] = variation['original_label']
+                
+                # Add RAG references if available
+                if 'rag_references' in variation and variation['rag_references']:
+                    current_metadata['rag_references'] = variation['rag_references']
+
+                # Archivo de ejercicio
+                exercise_content = variation.get('variation_content', '')
+                if exercise_content:
+                    exercise_file = output_dir / f"ex{i}_e{exam_number}.md"
+                    with open(exercise_file, 'w', encoding='utf-8') as f:
+                        f.write(self.generate_exercise_file(
+                            exercise_content, i, exam_number, current_metadata
+                        ))
+                    logger.info(f"Ejercicio creado: {exercise_file}")
+                
+                # Archivo de solución
+                solution_content = variation.get('variation_solution', '')
+                if solution_content:
+                    solution_file = output_dir / f"solucion_ex{i}_e{exam_number}.md"
+                    with open(solution_file, 'w', encoding='utf-8') as f:
+                        f.write(self.generate_solution_file(
+                            solution_content, i, exam_number, current_metadata
+                        ))
+                    logger.info(f"Solución creada: {solution_file}")
+                else:
+                    logger.warning(f"No hay solución para ejercicio {i}")
+            
+            # Actualizar downloads en frontmatter
+            self._update_downloads_in_frontmatter(exam_file, exam_number, len(variations))
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error generando examen: {e}")
+            return False
+    
+    def _update_downloads_in_frontmatter(self, exam_file: Path, exam_number: int,
+                                        num_exercises: int):
+        """
+        Actualiza la sección de downloads en el frontmatter del examen.
+        
+        Args:
+            exam_file: Archivo del examen
+            exam_number: Número del examen
+            num_exercises: Número de ejercicios
+        """
+        try:
+            content = exam_file.read_text(encoding='utf-8')
+            
+            # Extraer frontmatter
+            import re
+            frontmatter_match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+            if not frontmatter_match:
+                return
+            
+            frontmatter_str = frontmatter_match.group(1)
+            frontmatter = yaml.safe_load(frontmatter_str) or {}
+            
+            # Crear lista de downloads
+            downloads = [
+                {'file': f'./examen{exam_number}.md', 'title': f'examen{exam_number}.md'},
+                {'file': f'./examen{exam_number}.pdf', 'title': f'examen{exam_number}.pdf'}
+            ]
+            
+            for i in range(1, num_exercises + 1):
+                downloads.append({
+                    'file': f'./solucion_ex{i}_e{exam_number}.md',
+                    'title': f'solucion_ex{i}_e{exam_number}.md'
+                })
+            
+            frontmatter['downloads'] = downloads
+            
+            # Reemplazar frontmatter
+            new_frontmatter_str = yaml.dump(
+                frontmatter, default_flow_style=False, allow_unicode=True, sort_keys=False
+            )
+            new_content = f"---\n{new_frontmatter_str}---\n\n" + content[frontmatter_match.end():]
+            
+            exam_file.write_text(new_content, encoding='utf-8')
+        except Exception as e:
+            logger.warning(f"No se pudo actualizar downloads: {e}")
+

evolutia/exercise_analyzer.py

@@ -0,0 +1,256 @@
+"""
+Analizador de complejidad de ejercicios.
+Identifica tipo, pasos, conceptos y variables de ejercicios.
+"""
+import re
+from typing import Dict, List, Set
+from collections import Counter
+
+try:
+    from utils.math_extractor import (
+        extract_math_expressions,
+        extract_variables,
+        count_math_operations,
+        estimate_complexity
+    )
+except ImportError:
+    from .utils.math_extractor import (
+        extract_math_expressions,
+        extract_variables,
+        count_math_operations,
+        estimate_complexity
+    )
+
+
+class ExerciseAnalyzer:
+    """Analiza la complejidad y estructura de ejercicios."""
+
+    # Palabras clave para identificación de tipo
+    DEMOSTRACION_KEYWORDS = [
+        'demuestre', 'demuestre que', 'pruebe', 'verifique', 'muestre que'
+    ]
+
+    CALCULO_KEYWORDS = [
+        'calcule', 'calcular', 'encuentre', 'determine', 'evalúe', 'evaluar'
+    ]
+
+    APLICACION_KEYWORDS = [
+        'considere', 'suponga', 'modelo', 'sistema físico', 'aplicación',
+        'dispositivo', 'campo', 'potencial'
+    ]
+
+    STEP_KEYWORDS = [
+        'primero', 'luego', 'finalmente', 'ahora', 'a continuación',
+        'por tanto', 'por lo tanto', 'en consecuencia', 'así',
+        'por otro lado', 'además', 'también'
+    ]
+
+    # Patrones compilados para búsqueda eficiente
+    TYPE_PATTERNS = {
+        'demostracion': re.compile('|'.join(map(re.escape, DEMOSTRACION_KEYWORDS)), re.IGNORECASE),
+        'calculo': re.compile('|'.join(map(re.escape, CALCULO_KEYWORDS)), re.IGNORECASE),
+        'aplicacion': re.compile('|'.join(map(re.escape, APLICACION_KEYWORDS)), re.IGNORECASE)
+    }
+
+    STEP_KEYWORDS_PATTERN = re.compile('|'.join(map(re.escape, STEP_KEYWORDS)), re.IGNORECASE)
+
+    # Conceptos matemáticos comunes
+    CONCEPT_PATTERNS = {
+        'vector_operations': [
+            r'\\vec', r'\\cdot', r'\\times', r'\\nabla',
+            r'producto\s+(escalar|vectorial)', r'gradiente', r'divergencia', r'rotacional'
+        ],
+        'coordinate_systems': [
+            r'coordenadas?\s+(cartesianas?|polares?|cilíndricas?|esféricas?|toroidales?)',
+            r'\\rho', r'\\theta', r'\\phi', r'\\hat\{e\}_'
+        ],
+        'integrals': [
+            r'\\int', r'\\oint', r'integral', r'teorema\s+(de\s+)?(Green|Stokes|Gauss)',
+            r'divergencia', r'rotacional'
+        ],
+        'differential_equations': [
+            r'\\frac\{d', r'\\partial', r'ecuaci[óo]n\s+diferencial',
+            r'EDP', r'EDO'
+        ],
+        'linear_algebra': [
+            r'\\begin\{matrix\}', r'\\begin\{pmatrix\}', r'\\begin\{bmatrix\}',
+            r'matriz', r'\\mathbf', r'autovalor', r'autovector'
+        ],
+        'complex_numbers': [
+            r'\\mathbb\{C\}', r'z\s*=', r'n[úu]mero\s+complejo',
+            r'\\Re', r'\\Im', r'\\arg'
+        ],
+        'series_expansions': [
+            r'\\sum', r'serie', r'expansi[óo]n', r'Fourier',
+            r'Taylor', r'\\sum_\{n=0\}'
+        ]
+    }
+
+    def __init__(self):
+        """Inicializa el analizador."""
+        pass
+
+    def identify_exercise_type(self, content: str) -> str:
+        """
+        Identifica el tipo de ejercicio.
+
+        Args:
+            content: Contenido del ejercicio
+
+        Returns:
+            Tipo de ejercicio: 'demostracion', 'calculo', 'aplicacion', 'mixto'
+        """
+        # Búsqueda optimizada con evaluación perezosa (short-circuit)
+        # Verificamos demostración primero ya que es determinante para 'mixto'
+        if self.TYPE_PATTERNS['demostracion'].search(content):
+            # Si es demostración, buscamos otros tipos para ver si es mixto
+            # Basta con encontrar uno de los dos para que sea mixto
+            if (self.TYPE_PATTERNS['calculo'].search(content) or
+                self.TYPE_PATTERNS['aplicacion'].search(content)):
+                return 'mixto'
+            return 'demostracion'
+
+        # Si no es demostración, buscamos cálculo
+        if self.TYPE_PATTERNS['calculo'].search(content):
+            return 'calculo'
+
+        # Finalmente aplicación
+        if self.TYPE_PATTERNS['aplicacion'].search(content):
+            return 'aplicacion'
+
+        return 'calculo'  # Por defecto
+
+    def count_solution_steps(self, solution_content: str) -> int:
+        """
+        Cuenta el número de pasos en una solución.
+
+        Busca indicadores de pasos como:
+        - Numeración (1., 2., etc.)
+        - Palabras clave (Primero, Luego, Finalmente, etc.)
+        - Bloques de ecuaciones separados
+
+        Args:
+            solution_content: Contenido de la solución
+
+        Returns:
+            Número estimado de pasos
+        """
+        if not solution_content:
+            return 0
+
+        # Contar numeración explícita
+        numbered_steps = len(re.findall(r'^\s*\d+[\.\)]\s+', solution_content, re.MULTILINE))
+
+        # Contar palabras clave de pasos
+        keyword_steps = len(self.STEP_KEYWORDS_PATTERN.findall(solution_content))
+
+        # Contar bloques de ecuaciones (align, equation)
+        equation_blocks = len(re.findall(
+            r'\\begin\{(align|equation|aligned|eqnarray)\}',
+            solution_content
+        ))
+
+        # Estimar pasos basado en separadores
+        separators = len(re.findall(r'\n\n+', solution_content))
+
+        # Tomar el máximo de los métodos
+        estimated_steps = max(
+            numbered_steps,
+            keyword_steps // 2,  # Dividir porque pueden repetirse
+            equation_blocks,
+            separators // 2
+        )
+
+        return max(1, estimated_steps)  # Mínimo 1 paso
+
+    def identify_concepts(self, content: str) -> Set[str]:
+        """
+        Identifica conceptos matemáticos presentes en el contenido.
+
+        Args:
+            content: Contenido a analizar
+
+        Returns:
+            Conjunto de conceptos identificados
+        """
+        concepts = set()
+
+        for concept_name, patterns in self.CONCEPT_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, content, re.IGNORECASE):
+                    concepts.add(concept_name)
+                    break
+
+        return concepts
+
+    def analyze(self, exercise: Dict) -> Dict:
+        """
+        Analiza un ejercicio completo y retorna metadatos de complejidad.
+
+        Args:
+            exercise: Diccionario con información del ejercicio
+                - 'content': Contenido del ejercicio
+                - 'solution': Contenido de la solución (opcional)
+
+        Returns:
+            Diccionario con análisis de complejidad
+        """
+        content = exercise.get('content', '')
+        solution = exercise.get('solution', '')
+
+        # Extraer expresiones matemáticas
+        math_expressions = extract_math_expressions(content)
+        if solution:
+            math_expressions.extend(extract_math_expressions(solution))
+
+        # Extraer variables
+        variables = extract_variables(math_expressions)
+
+        # Identificar tipo
+        exercise_type = self.identify_exercise_type(content)
+
+        # Contar pasos en solución
+        solution_steps = self.count_solution_steps(solution) if solution else 0
+
+        # Identificar conceptos
+        all_content = content + '\n' + (solution or '')
+        concepts = self.identify_concepts(all_content)
+
+        # Calcular complejidad matemática
+        math_complexity = estimate_complexity(math_expressions)
+
+        # Contar operaciones
+        total_operations = {
+            'integrals': 0,
+            'derivatives': 0,
+            'sums': 0,
+            'vectors': 0,
+            'matrices': 0,
+            'functions': 0
+        }
+        for expr in math_expressions:
+            ops = count_math_operations(expr)
+            for key in total_operations:
+                total_operations[key] += ops[key]
+
+        # Calcular complejidad total
+        total_complexity = (
+            math_complexity +
+            solution_steps * 2.0 +
+            len(variables) * 0.5 +
+            len(concepts) * 1.5 +
+            sum(total_operations.values()) * 0.5
+        )
+
+        return {
+            'type': exercise_type,
+            'solution_steps': solution_steps,
+            'variables': list(variables),
+            'num_variables': len(variables),
+            'concepts': list(concepts),
+            'num_concepts': len(concepts),
+            'math_complexity': math_complexity,
+            'operations': total_operations,
+            'total_complexity': total_complexity,
+            'num_math_expressions': len(math_expressions)
+        }