Desarrollo Empírico de SIEsP: De la Incertidumbre en Crudo a la Entropía 1.04
En el cuaderno anterior presentamos las bases teóricas del SIEsP (Sistema de Inferencia de Entropía en Python). Sin embargo, la verdadera ingeniería de software soberana no se valida en pizarras abstractas, sino en la trinchera de la terminal.
Este cuaderno documenta el proceso científico real de calibración del prototipo dentro de un entorno virtual aislado (venv), analizando los errores sintácticos de compatibilidad de API y mostrando la drástica reducción del índice de entropía hasta alcanzar un estado de orden de 1.04.
1. Progresión Empírica de las Pruebas en Terminal
A lo largo de las sesiones de prueba sobre el motor de inferencia y los scripts de prueba, se registraron cuatro fases marcadas por la refactorización lógica y técnica:
| Fase del Experimento | Sintaxis (Pylint) | Complejidad (Radon) | Tests (Pytest) | Rendimiento | Entropía Total |
|---|---|---|---|---|---|
| 1. En Crudo (Inicial) Fallo en API pylint y sintaxis timeit |
10.00 (Error API) | 7.00 | 0.00 (1 passed) | 5.00 (Error syntax) | 5.90 |
| 2. Motor Calibrado Captura io.StringIO y stmt en timeit |
5.00 | 7.00 | 0.00 (1 passed) | 0.00 | 3.40 |
| 3. Corrección de Nomenclatura Sustitución de (-) por (_) en módulos |
2.50 | 7.00 | 0.00 (1 passed) | 0.00 | 2.40 |
| 4. Asalto Definitivo Separación de tests y tipado estricto |
1.11 | 3.00 | 0.00 | 0.00 | 1.04 |
Arquitectura del Motor Definitivo (entropy_inference.py)
Tras limar las asperezas de la API, el script central del Guardián quedó estructurado de forma modular y resiliente:
"""Módulo optimizado para el cálculo de incertidumbre bajo el canon de entropía cero."""
import argparse
import timeit
import io
import sys
import os
from pylint.lint import Run
from radon.complexity import cc_visit
import pytest
from typing import Dict, Tuple
"""Motor de Inferencia de Entropía en Python (SIEsP) — Proyecto Ciber Sapiens.
Este módulo actúa como el Guardián Cósmico de calidad de software, evaluando la
incertidumbre y el ruido técnico de scripts en Python mediante una métrica ponderada.
Áreas de auditoría:
1. Sintaxis y estilo de código (pylint).
2. Complejidad ciclomática y rutas lógicas (radon).
3. Validación funcional y suite de pruebas (pytest).
4. Coste computacional e importación en caliente (timeit).
Filosofía:
Gravitar asintóticamente hacia el cero absoluto de entropía, disipando la fricción
del código hasta alcanzar la sencillez y elegancia soberana del 'Shibumi'.
Uso:
$ python entropy_inference.py <ruta_al_script.py>
Autor: —@alpha
Sitio web: segfdo.es
"""
def analyze_syntax(script_path: str) -> float:
"""Analiza la calidad del código capturando la nota global de pylint de forma compatible."""
old_stdout = sys.stdout
try:
sys.stdout = io.StringIO()
runner = Run([script_path, '--score=y'], exit=False)
sys.stdout = old_stdout
pylint_score = runner.linter.stats.global_note
return max(0.0, 10.0 - float(pylint_score))
except Exception as e:
sys.stdout = old_stdout
try:
return max(0.0, 10.0 - float(runner.linter.stats.global_note))
except Exception:
print(f"Error al analizar sintaxis: {e}")
return 10.0
def analyze_complexity(script_path: str) -> float:
"""Calcula la complejidad ciclomática del script usando radon."""
try:
with open(script_path, 'r', encoding='utf-8') as file:
code = file.read()
complexity_results = cc_visit(code)
total_complexity = sum(func.complexity for func in complexity_results)
return total_complexity
except Exception as e:
print(f"Error al analizar complejidad: {e}")
return 10.0
def analyze_tests(script_path: str) -> float:
"""Ejecuta las pruebas unitarias asociadas buscando el archivo test_<script>.py."""
try:
dir_name = os.path.dirname(script_path)
base_name = os.path.basename(script_path)
test_file = os.path.join(dir_name, f"test_{base_name}")
target = test_file if os.path.exists(test_file) else script_path
result = pytest.main([target, '-q'])
# Si el código de pytest es 5 (no tests encontrados en el objetivo), se neutraliza
if result == 5:
return 0.0
return float(result)
except Exception as e:
print(f"Error al ejecutar pruebas: {e}")
return 5.0
def analyze_performance(script_path: str) -> float:
"""Mide el tiempo de importación y ejecución del script."""
try:
module_name = script_path.replace('.py', '').replace('/', '.')
execution_time = timeit.timeit(stmt=f"import {module_name}", number=100) / 100
return execution_time * 1000.0
except Exception as e:
return 5.0
def calculate_entropy(script_path: str) -> Tuple[float, Dict[str, float]]:
syntax_entropy = analyze_syntax(script_path)
complexity_entropy = analyze_complexity(script_path)
test_entropy = analyze_tests(script_path)
performance_entropy = analyze_performance(script_path)
weights = {"syntax": 0.4, "complexity": 0.2, "tests": 0.3, "performance": 0.1}
total_entropy = (
weights["syntax"] * syntax_entropy +
weights["complexity"] * complexity_entropy +
weights["tests"] * test_entropy +
weights["performance"] * performance_entropy
)
details = {
"syntax": syntax_entropy,
"complexity": complexity_entropy,
"tests": test_entropy,
"performance": performance_entropy
}
return total_entropy, details
def generate_report(total_entropy: float, details: Dict[str, float]) -> str:
report = [
"Reporte de Entropía del Script (SIEsP)",
"=" * 35,
f"Entropía Total: {total_entropy:.2f}",
"\nDetalles de Métricas:",
f"- Sintaxis (pylint): {details['syntax']:.2f} (0 = óptimo, 10 = alta incertidumbre)",
f"- Complejidad ciclomática: {details['complexity']:.2f} (menor es mejor)",
f"- Pruebas fallidas: {details['tests']:.2f} (0 = 100% éxito)",
f"- Rendimiento (ms escalado): {details['performance']:.2f} (menor es mejor)",
"",
"Sugerencias del Guardián:",
]
if details["syntax"] > 3:
report.append("- Revisar formateo y normas de estilo reportadas por pylint.")
if details["complexity"] > 5:
report.append("- Reducir la complejidad ciclomática desglosando funciones.")
if details["tests"] > 0:
report.append("- Corregir pruebas unitarias fallidas.")
if details["performance"] > 2:
report.append("- Optimizar tiempo de ejecución en caliente.")
return "\n".join(report)
def main():
parser = argparse.ArgumentParser(description="Sistema de Inferencia de Entropía (SIEsP).")
parser.add_argument("script", help="Ruta al archivo Python a analizar.")
args = parser.parse_args()
total_entropy, details = calculate_entropy(args.script)
print(generate_report(total_entropy, details))
if __name__ == "__main__":
main()2. Hallazgos de Trinchera y Lecciones Técnicas
A. Compatibilidad con la API moderna de Pylint (3.x+):
Al invocar pylint.lint.Run programáticamente, versiones recientes eliminaron el argumento do_exit. Para evitar colapsos, el motor captura la salida redirigiendo sys.stdout con io.StringIO() e invocando exit=False.
B. La Trampa de Sintaxis en Módulos y Timeit:
Pasar cadenas con banderas de terminal (como -c) dentro de timeit.timeit() genera errores de sintaxis dinámicos. Debe usarse la instrucción exacta stmt="import modulo".
C. La Regla del Guion Bajo (_) en Python:
Nombrar archivos como mi_script-optimizado.py causa que Python interprete el guion medio (-) como un operador aritmético de resta en los enunciados import. Todos los archivos y módulos deben usar estrictamente guion bajo.
3. La Estructura del Código Optimizado (Entropía 1.04)
Para disipar la complejidad acumulada, se separó la lógica de negocio de la suite de pruebas unitarias:
Lógica pura (mi_script_optimizado_2.py):
"""Módulo optimizado para el cálculo de factoriales bajo el canon de entropía cero."""
def calcular_factorial(n: int) -> int:
"""Calcula el valor factorial de un número entero no negativo.
Args:
n: Número entero del cual se calculará el factorial.
Returns:
El resultado del cálculo factorial.
"""
result = 1
for i in range(2, n + 1):
result *= i
return result
def main() -> None:
"""Punto de entrada principal para la ejecución en caliente."""
print(calcular_factorial(5))
if __name__ == "__main__":
main()Suite de pruebas satélite (test_mi_script_optimizado_2.py):
"""Suite de pruebas unitarias para validar el módulo de factoriales."""
from mi_script_optimizado_2 import calcular_factorial
def test_calcular_factorial() -> None:
"""Valida los casos base y de borde del cálculo factorial."""
assert calcular_factorial(5) == 120, "Factorial de 5 debe ser 120"
assert calcular_factorial(0) == 1, "Factorial de 0 debe ser 1"
assert calcular_factorial(1) == 1, "Factorial de 1 debe ser 1"4. Salida Final del Guardián
(venv) alpfa_@alpfa_:~/siesp-prototipo$ python entropy_inference.py mi_script_optimizado_2.py
. [100%]
1 passed in 0.02s
Reporte de Entropía del Script (SIEsP)
===================================
Entropía Total: 1.04
Detalles de Métricas:
- Sintaxis (pylint): 1.11 (0 = óptimo, 10 = alta incertidumbre)
- Complejidad ciclomática: 3.00 (menor es mejor)
- Pruebas fallidas: 0.00 (0 = 100% éxito)
- Rendimiento (ms escalado): 0.00 (menor es mejor)
Sugerencias del Guardián:
(Sin sugerencias pendientes. Estado de simetría alcanzado.)