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

evolutia/utils/markdown_parser.py

@@ -1,160 +1,186 @@
-"""
-Utilidades para parsear archivos Markdown/MyST y extraer ejercicios y soluciones.
-"""
-import re
-import yaml
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-
-def extract_frontmatter(content: str) -> Tuple[Dict, str]:
-    """
-    Extrae el frontmatter YAML del contenido Markdown.
-    
-    Args:
-        content: Contenido completo del archivo
-        
-    Returns:
-        Tupla (frontmatter_dict, contenido_sin_frontmatter)
-    """
-    frontmatter_pattern = r'^---\s*\n(.*?)\n---\s*\n'
-    match = re.match(frontmatter_pattern, content, re.DOTALL)
-    
-    if match:
-        frontmatter_str = match.group(1)
-        try:
-            frontmatter = yaml.safe_load(frontmatter_str) or {}
-            content_without_frontmatter = content[match.end():]
-            return frontmatter, content_without_frontmatter
-        except yaml.YAMLError:
-            return {}, content
-    return {}, content
-
-
-def extract_exercise_blocks(content: str) -> List[Dict]:
-    """
-    Extrae bloques de ejercicio del formato MyST.
-    
-    Busca bloques del tipo:
-    ```{exercise} N
-    :label: exN-XX
-    ...
-    ```
-    
-    Args:
-        content: Contenido Markdown
-        
-    Returns:
-        Lista de diccionarios con información de cada ejercicio
-    """
-    exercises = []
-    
-    # Patrón para bloques de ejercicio MyST
-    # Captura delimitador (grupo 1), label (grupo 2) y contenido (grupo 3)
-    # Usa backreference \1 para coincidir con la longitud exacta del delimitador de cierre
-    exercise_pattern = r'(`{3,4})\{exercise\}(?:\s+\d+)?\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
-    
-    matches = re.finditer(exercise_pattern, content, re.DOTALL)
-    
-    for match in matches:
-        # group(1) es el delimitador
-        label = match.group(2)
-        exercise_content = match.group(3).strip()
-        
-        # Buscar si hay un include dentro
-        include_match = re.search(r'```\{include\}\s+(.+?)\s*```', exercise_content, re.DOTALL)
-        if include_match:
-            include_path = include_match.group(1).strip()
-            exercises.append({
-                'label': label,
-                'content': exercise_content,
-                'include_path': include_path,
-                'type': 'include'
-            })
-        else:
-            exercises.append({
-                'label': label,
-                'content': exercise_content,
-                'include_path': None,
-                'type': 'inline'
-            })
-    
-    return exercises
-
-
-def extract_solution_blocks(content: str) -> List[Dict]:
-    """
-    Extrae bloques de solución del formato MyST.
-    
-    Busca bloques del tipo:
-    ````{solution} exN-XX
-    :label: solution-exN-XX
-    ...
-    ````
-    
-    Args:
-        content: Contenido Markdown
-        
-    Returns:
-        Lista de diccionarios con información de cada solución
-    """
-    solutions = []
-    
-    # Patrón para bloques de solución MyST
-    # Captura delimitador (grupo 1), exercise_label (grupo 2), solution_label (grupo 3), contenido (grupo 4)
-    solution_pattern = r'(`{3,4})\{solution\}\s+(\S+)\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
-    
-    matches = re.finditer(solution_pattern, content, re.DOTALL)
-    
-    for match in matches:
-        # group(1) es delimitador
-        exercise_label = match.group(2)
-        solution_label = match.group(3)
-        solution_content = match.group(4).strip()
-        
-        # Buscar includes dentro de la solución
-        include_matches = re.finditer(r'```\{include\}\s+(.+?)\s*```', solution_content, re.DOTALL)
-        include_paths = [m.group(1).strip() for m in include_matches]
-        
-        solutions.append({
-            'exercise_label': exercise_label,
-            'label': solution_label,
-            'content': solution_content,
-            'include_paths': include_paths
-        })
-    
-    return solutions
-
-
-def read_markdown_file(file_path: Path) -> str:
-    """
-    Lee un archivo Markdown y retorna su contenido.
-    
-    Args:
-        file_path: Ruta al archivo
-        
-    Returns:
-        Contenido del archivo
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            return f.read()
-    except Exception as e:
-        raise IOError(f"Error leyendo archivo {file_path}: {e}")
-
-
-def resolve_include_path(include_path: str, base_dir: Path) -> Path:
-    """
-    Resuelve una ruta de include relativa a un directorio base.
-    
-    Args:
-        include_path: Ruta relativa del include
-        base_dir: Directorio base
-        
-    Returns:
-        Ruta absoluta resuelta
-    """
-    # Limpiar la ruta (puede tener ./ o espacios)
-    clean_path = include_path.strip().lstrip('./')
-    return (base_dir / clean_path).resolve()
+"""
+Utilidades para parsear archivos Markdown/MyST y extraer ejercicios y soluciones.
+"""
+import re
+import yaml
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union
+
+logger = logging.getLogger(__name__)
+
+
+def extract_frontmatter(content: str) -> Tuple[Dict[str, str], str]:
+    """
+    Extrae el frontmatter YAML del contenido Markdown.
+
+    Args:
+        content: Contenido completo del archivo
+
+    Returns:
+        Tupla (frontmatter_dict, contenido_sin_frontmatter)
+    """
+    if not content:
+        return {}, ""
+
+    frontmatter_pattern = r'^---\s*\n(.*?)\n---\s*\n'
+    match = re.match(frontmatter_pattern, content, re.DOTALL)
+
+    if match:
+        frontmatter_str = match.group(1)
+        try:
+            frontmatter = yaml.safe_load(frontmatter_str) or {}
+            content_without_frontmatter = content[match.end():]
+            logger.debug(f"[MarkdownParser] Frontmatter extraído: {len(frontmatter)} campos")
+            return frontmatter, content_without_frontmatter
+        except yaml.YAMLError as e:
+            logger.warning(f"[MarkdownParser] Error parseando YAML frontmatter: {e}")
+            return {}, content
+    logger.debug("[MarkdownParser] No se encontró frontmatter")
+    return {}, content
+
+
+def extract_exercise_blocks(content: str) -> List[Dict[str, Union[str, None]]]:
+    """
+    Extrae bloques de ejercicio del formato MyST.
+
+    Busca bloques del tipo:
+    ```{exercise} N
+    :label: exN-XX
+    ...
+    ```
+
+    Args:
+        content: Contenido Markdown
+
+    Returns:
+        Lista de diccionarios con información de cada ejercicio
+    """
+    exercises = []
+
+    if not content:
+        return exercises
+
+    # Patrón para bloques de ejercicio MyST
+    # Captura delimitador (grupo 1), label (grupo 2) y contenido (grupo 3)
+    # Usa backreference \1 para coincidir con la longitud exacta del delimitador de cierre
+    exercise_pattern = r'(`{3,4})\{exercise\}(?:\s+\d+)?\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
+
+    matches = re.finditer(exercise_pattern, content, re.DOTALL)
+
+    for match in matches:
+        # group(1) es el delimitador
+        label = match.group(2)
+        exercise_content = match.group(3).strip()
+
+        # Buscar si hay un include dentro
+        include_match = re.search(r'```\{include\}\s+(.+?)\s*```', exercise_content, re.DOTALL)
+        if include_match:
+            include_path = include_match.group(1).strip()
+            exercises.append({
+                'label': label,
+                'content': exercise_content,
+                'include_path': include_path,
+                'type': 'include'
+            })
+        else:
+            exercises.append({
+                'label': label,
+                'content': exercise_content,
+                'include_path': None,
+                'type': 'inline'
+            })
+
+    logger.debug(f"[MarkdownParser] Extraídos {len(exercises)} bloques de ejercicio")
+    return exercises
+
+
+def extract_solution_blocks(content: str) -> List[Dict[str, Union[str, List[str]]]]:
+    """
+    Extrae bloques de solución del formato MyST.
+
+    Busca bloques del tipo:
+    ````{solution} exN-XX
+    :label: solution-exN-XX
+    ...
+    ````
+
+    Args:
+        content: Contenido Markdown
+
+    Returns:
+        Lista de diccionarios con información de cada solución
+    """
+    solutions = []
+
+    if not content:
+        return solutions
+
+    # Patrón para bloques de solución MyST
+    # Captura delimitador (grupo 1), exercise_label (grupo 2), solution_label (grupo 3), contenido (grupo 4)
+    solution_pattern = r'(`{3,4})\{solution\}\s+(\S+)\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
+
+    matches = re.finditer(solution_pattern, content, re.DOTALL)
+
+    for match in matches:
+        # group(1) es delimitador
+        exercise_label = match.group(2)
+        solution_label = match.group(3)
+        solution_content = match.group(4).strip()
+
+        # Buscar includes dentro de la solución
+        include_matches = re.finditer(r'```\{include\}\s+(.+?)\s*```', solution_content, re.DOTALL)
+        include_paths = [m.group(1).strip() for m in include_matches]
+
+        solutions.append({
+            'exercise_label': exercise_label,
+            'label': solution_label,
+            'content': solution_content,
+            'include_paths': include_paths
+        })
+
+    logger.debug(f"[MarkdownParser] Extraídos {len(solutions)} bloques de solución")
+    return solutions
+
+
+def read_markdown_file(file_path: Union[Path, str]) -> str:
+    """
+    Lee un archivo Markdown y retorna su contenido.
+
+    Args:
+        file_path: Ruta al archivo
+
+    Returns:
+        Contenido del archivo
+
+    Raises:
+        IOError: Si hay error leyendo el archivo
+    """
+    file_path = Path(file_path)
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            logger.debug(f"[MarkdownParser] Archivo leído exitosamente: {file_path} (longitud={len(content)})")
+            return content
+    except Exception as e:
+        logger.error(f"[MarkdownParser] Error leyendo archivo {file_path}: {e}")
+        raise IOError(f"Error leyendo archivo {file_path}: {e}")
+
+
+def resolve_include_path(include_path: str, base_dir: Union[Path, str]) -> Path:
+    """
+    Resuelve una ruta de include relativa a un directorio base.
+
+    Args:
+        include_path: Ruta relativa del include
+        base_dir: Directorio base
+
+    Returns:
+        Ruta absoluta resuelta
+    """
+    # Limpiar la ruta (puede tener ./ o espacios)
+    clean_path = include_path.strip().lstrip('./')
+    resolved_path = (Path(base_dir) / clean_path).resolve()
+    logger.debug(f"[MarkdownParser] Ruta include resuelta: {include_path} -> {resolved_path}")
+    return resolved_path
 

evolutia/utils/math_extractor.py

@@ -1,144 +1,153 @@
-"""
-Utilidades para extraer y analizar expresiones matemáticas de archivos Markdown.
-"""
-import re
-from typing import List, Dict, Set
-
-# Patrones comunes para variables
-# Variables latinas: \vec{A}, A, \mathbf{B}, etc.
-LATIN_PATTERN = re.compile(r'\\vec\{([A-Za-z])\}|\\mathbf\{([A-Za-z])\}|\\hat\{([A-Za-z])\}|([A-Za-z])(?![a-z])')
-
-# Letras griegas: \alpha, \beta, \theta, etc.
-GREEK_PATTERN = re.compile(r'\\(alpha|beta|gamma|delta|epsilon|theta|phi|rho|omega|sigma|lambda|mu|nu|pi|tau)')
-
-
-def extract_math_expressions(content: str) -> List[str]:
-    r"""
-    Extrae todas las expresiones matemáticas del contenido.
-
-    Busca expresiones en formato LaTeX:
-    - Inline: $...$ o \(...\)
-    - Display: $$...$$ o \[...\]
-    - Math blocks: :::{math} ... :::
-
-    Args:
-        content: Contenido Markdown
-
-    Returns:
-        Lista de expresiones matemáticas encontradas
-    """
-    expressions = []
-
-    # 1. Bloques math de MyST: :::{math} ... :::
-    # Se procesan primero y se eliminan del contenido para evitar duplicados si contienen $ o $$
-    math_block_pattern = r':::\{math\}\s*(.*?)\s*:::'
-    for match in re.finditer(math_block_pattern, content, re.DOTALL):
-        expr = match.group(1).strip()
-        if expr:
-            expressions.append(expr)
-    content = re.sub(math_block_pattern, '', content, flags=re.DOTALL)
-
-    # 2. Expresiones display: $$...$$ o \[...\]
-    display_pattern = r'\$\$([^$]+)\$\$|\\\[([^\]]+)\\\]'
-    for match in re.finditer(display_pattern, content, re.DOTALL):
-        expr = match.group(1) or match.group(2)
-        if expr:
-            expressions.append(expr.strip())
-    content = re.sub(display_pattern, '', content, flags=re.DOTALL)
-
-    # 3. Expresiones inline: $...$ o \(...\)
-    inline_pattern = r'\$([^$]+)\$|\\\(([^\)]+)\\\)'
-    for match in re.finditer(inline_pattern, content):
-        expr = match.group(1) or match.group(2)
-        if expr:
-            expressions.append(expr.strip())
-
-    return expressions
-
-
-def extract_variables(math_expressions: List[str]) -> Set[str]:
-    """
-    Extrae variables de expresiones matemáticas.
-
-    Identifica letras griegas, variables latinas, y símbolos comunes.
-
-    Args:
-        math_expressions: Lista de expresiones matemáticas
-
-    Returns:
-        Conjunto de variables identificadas
-    """
-    variables = set()
-
-    for expr in math_expressions:
-        # Buscar variables latinas
-        for match in LATIN_PATTERN.finditer(expr):
-            var = match.group(1) or match.group(2) or match.group(3) or match.group(4)
-            if var and var.isalpha():
-                variables.add(var)
-
-        # Buscar letras griegas
-        for match in GREEK_PATTERN.finditer(expr):
-            variables.add(match.group(1))
-
-    return variables
-
-
-def count_math_operations(expression: str) -> Dict[str, int]:
-    """
-    Cuenta operaciones matemáticas en una expresión.
-
-    Args:
-        expression: Expresión matemática
-
-    Returns:
-        Diccionario con conteo de operaciones
-    """
-    operations = {
-        'integrals': len(re.findall(r'\\int|\\oint', expression)),
-        'derivatives': len(re.findall(r'\\partial|\\nabla|\\frac\{d', expression)),
-        'sums': len(re.findall(r'\\sum|\\prod', expression)),
-        'vectors': len(re.findall(r'\\vec|\\mathbf', expression)),
-        'matrices': len(re.findall(r'\\begin\{matrix\}|\\begin\{pmatrix\}|\\begin\{bmatrix\}', expression)),
-        'functions': len(re.findall(r'\\sin|\\cos|\\tan|\\exp|\\log|\\ln', expression)),
-    }
-    return operations
-
-
-def estimate_complexity(expressions: List[str]) -> float:
-    """
-    Estima la complejidad matemática de un conjunto de expresiones.
-
-    Args:
-        expressions: Lista de expresiones matemáticas
-
-    Returns:
-        Puntuación de complejidad (mayor = más complejo)
-    """
-    if not expressions:
-        return 0.0
-
-    total_complexity = 0.0
-
-    for expr in expressions:
-        # Longitud de la expresión
-        total_complexity += len(expr) * 0.01
-
-        # Operaciones complejas
-        ops = count_math_operations(expr)
-        total_complexity += ops['integrals'] * 2.0
-        total_complexity += ops['derivatives'] * 1.5
-        total_complexity += ops['sums'] * 1.5
-        total_complexity += ops['vectors'] * 1.0
-        total_complexity += ops['matrices'] * 2.5
-        total_complexity += ops['functions'] * 0.5
-
-        # Número de variables
-        vars_count = len(extract_variables([expr]))
-        total_complexity += vars_count * 0.3
-
-        # Bloques align (ecuaciones múltiples)
-        if '\\begin{align' in expr or '\\begin{aligned' in expr:
-            total_complexity += 2.0
-
-    return total_complexity
+"""
+Utilidades para extraer y analizar expresiones matemáticas de archivos Markdown.
+"""
+import re
+import logging
+from typing import List, Dict, Set, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Patrones comunes para variables
+# Variables latinas: \vec{A}, A, \mathbf{B}, etc.
+LATIN_PATTERN = re.compile(r'\\vec\{([A-Za-z])\}|\\mathbf\{([A-Za-z])\}|\\hat\{([A-Za-z])\}|([A-Za-z])(?![a-z])')
+
+# Letras griegas: \alpha, \beta, \theta, etc.
+GREEK_PATTERN = re.compile(r'\\(alpha|beta|gamma|delta|epsilon|theta|phi|rho|omega|sigma|lambda|mu|nu|pi|tau)')
+
+
+def extract_math_expressions(content: str) -> List[str]:
+    r"""
+    Extrae todas las expresiones matemáticas del contenido.
+
+    Busca expresiones en formato LaTeX:
+    - Inline: $...$ o \(...\)
+    - Display: $$...$$ o \[...\]
+    - Math blocks: :::{math} ... :::
+
+    Args:
+        content: Contenido Markdown
+
+    Returns:
+        Lista de expresiones matemáticas encontradas
+    """
+    if not content:
+        return []
+
+    expressions = []
+
+    # 1. Bloques math de MyST: :::{math} ... :::
+    # Se procesan primero y se eliminan del contenido para evitar duplicados si contienen $ o $$
+    math_block_pattern = r':::\{math\}\s*(.*?)\s*:::'
+    for match in re.finditer(math_block_pattern, content, re.DOTALL):
+        expr = match.group(1).strip()
+        if expr:
+            expressions.append(expr)
+    content = re.sub(math_block_pattern, '', content, flags=re.DOTALL)
+
+    # 2. Expresiones display: $$...$$ o \[...\]
+    display_pattern = r'\$\$([^$]+)\$\$|\\\[([^\]]+)\\\]'
+    for match in re.finditer(display_pattern, content, re.DOTALL):
+        expr = match.group(1) or match.group(2)
+        if expr:
+            expressions.append(expr.strip())
+    content = re.sub(display_pattern, '', content, flags=re.DOTALL)
+
+    # 3. Expresiones inline: $...$ o \(...\)
+    inline_pattern = r'\$([^$]+)\$|\\\(([^\)]+)\\\)'
+    for match in re.finditer(inline_pattern, content):
+        expr = match.group(1) or match.group(2)
+        if expr:
+            expressions.append(expr.strip())
+
+    logger.debug(f"[MathExtractor] Extraídas {len(expressions)} expresiones matemáticas del contenido")
+    return expressions
+
+
+def extract_variables(math_expressions: List[str]) -> Set[str]:
+    """
+    Extrae variables de expresiones matemáticas.
+
+    Identifica letras griegas, variables latinas, y símbolos comunes.
+
+    Args:
+        math_expressions: Lista de expresiones matemáticas
+
+    Returns:
+        Conjunto de variables identificadas
+    """
+    variables = set()
+
+    for expr in math_expressions:
+        # Buscar variables latinas
+        for match in LATIN_PATTERN.finditer(expr):
+            var = match.group(1) or match.group(2) or match.group(3) or match.group(4)
+            if var and var.isalpha():
+                variables.add(var)
+
+        # Buscar letras griegas
+        for match in GREEK_PATTERN.finditer(expr):
+            variables.add(match.group(1))
+
+    logger.debug(f"[MathExtractor] Extraídas {len(variables)} variables de {len(math_expressions)} expresiones")
+    return variables
+
+
+def count_math_operations(expression: str) -> Dict[str, int]:
+    """
+    Cuenta operaciones matemáticas en una expresión.
+
+    Args:
+        expression: Expresión matemática
+
+    Returns:
+        Diccionario con conteo de operaciones
+    """
+    operations = {
+        'integrals': len(re.findall(r'\\int|\\oint', expression)),
+        'derivatives': len(re.findall(r'\\partial|\\nabla|\\frac\{d', expression)),
+        'sums': len(re.findall(r'\\sum|\\prod', expression)),
+        'vectors': len(re.findall(r'\\vec|\\mathbf', expression)),
+        'matrices': len(re.findall(r'\\begin\{matrix\}|\\begin\{pmatrix\}|\\begin\{bmatrix\}', expression)),
+        'functions': len(re.findall(r'\\sin|\\cos|\\tan|\\exp|\\log|\\ln', expression)),
+    }
+    return operations
+
+
+def estimate_complexity(expressions: List[str]) -> float:
+    """
+    Estima la complejidad matemática de un conjunto de expresiones.
+
+    Args:
+        expressions: Lista de expresiones matemáticas
+
+    Returns:
+        Puntuación de complejidad (mayor = más complejo)
+    """
+    if not expressions:
+        return 0.0
+
+    total_complexity = 0.0
+
+    for expr in expressions:
+        # Longitud de la expresión
+        total_complexity += len(expr) * 0.01
+
+        # Operaciones complejas
+        ops = count_math_operations(expr)
+        total_complexity += ops['integrals'] * 2.0
+        total_complexity += ops['derivatives'] * 1.5
+        total_complexity += ops['sums'] * 1.5
+        total_complexity += ops['vectors'] * 1.0
+        total_complexity += ops['matrices'] * 2.5
+        total_complexity += ops['functions'] * 0.5
+
+        # Número de variables
+        vars_count = len(extract_variables([expr]))
+        total_complexity += vars_count * 0.3
+
+        # Bloques align (ecuaciones múltiples)
+        if '\\begin{align' in expr or '\\begin{aligned' in expr:
+            total_complexity += 2.0
+
+    logger.debug(f"[MathExtractor] Complejidad estimada: {total_complexity:.2f} (de {len(expressions)} expresiones)")
+    return total_complexity

evolutia/validation/__init__.py

@@ -0,0 +1 @@
+# Tests package for EvolutIA validation