En este tutorial, creamos un flujo de trabajo de análisis de complejidad cognitiva de un extremo a otro utilizando complexipy. Comenzamos midiendo la complejidad directamente a partir de cadenas de código sin formato, luego escalamos el mismo análisis a archivos individuales y a un directorio de proyecto completo. A lo largo del camino, generamos informes legibles por máquina, los normalizamos en marcos de datos estructurados y visualizamos distribuciones de complejidad para comprender cómo se acumula la profundidad de las decisiones en las funciones. Al tratar la complejidad cognitiva como una señal de ingeniería mensurable, mostramos cómo se puede integrar de forma natural en el desarrollo cotidiano de Python y en los controles de calidad. Consulta los CÓDIGOS COMPLETOS aquí.
Configuramos el entorno instalando las bibliotecas necesarias e importando todas las dependencias necesarias para el análisis y la visualización. Nos aseguramos de que la computadora portátil sea completamente autónoma y esté lista para ejecutarse en Google Colab sin configuración externa. Constituye la columna vertebral de la ejecución de todo lo que sigue.
Comenzamos analizando una cadena de código Python sin procesar para comprender la complejidad cognitiva a nivel de función. Inspeccionamos directamente cómo los condicionales anidados y el flujo de control contribuyen a la complejidad. Nos ayuda a validar el comportamiento central de complexipy antes de escalar a archivos reales.
Construimos mediante programación un proyecto Python pequeño pero realista con múltiples módulos y archivos de prueba. Incluimos intencionalmente patrones variados de flujo de control para crear diferencias significativas en complejidad. Consulta los CÓDIGOS COMPLETOS aquí.
“complexipy”,
“.”,
“–max-complexity-allowed”, str(max_allowed),
“–output-json”,
“–output-csv”,
]
proc = subprocess.run(cmd, cwd=str(project_dir), capture_output=True, text=True) preferido_csv = dir_proyecto / “complexipy.csv” json_preferido = dir_proyecto / “complexipy.json” csv_candidates = []
json_candidatos = []
si preferido_csv.exists(): csv_candidates.append(preferred_csv) si preferido_json.exists(): json_candidates.append(preferred_json) csv_candidates += lista(project_dir.glob(“*.csv”)) + lista(project_dir.glob(“**/*.csv”)) json_candidates += list(project_dir.glob(“*.json”)) + list(project_dir.glob(“**/*.json”)) def uniq(rutas): visto = set() out = []
para p en rutas: p = p.resolve() si p no está visto y p.is_file(): visto.add(p) out.append(p) devuelve csv_candidates = uniq(csv_candidates) json_candidates = uniq(json_candidates) def pick_best(rutas): si no rutas: devuelve Ninguno rutas = sorted(rutas, clave=lambda p: p.stat().st_mtime, reverse=True) rutas de retorno[0]
devolver proc.returncode, pick_best(csv_candidates), pick_best(json_candidates) rc, csv_report, json_report = run_complexipy_cli(root, MAX_ALLOWED)
Analizamos un archivo fuente real utilizando la API de Python y luego ejecutamos la CLI compleja en todo el proyecto. Ejecutamos la CLI desde el directorio de trabajo correcto para generar informes de manera confiable. Este paso une el uso de API local con flujos de trabajo de análisis estático de estilo de producción.
Cargamos los informes de complejidad generados en pandas y los normalizamos en una tabla de nivel de función. Manejamos múltiples esquemas de informes posibles para mantener el flujo de trabajo sólido. Esta representación estructurada nos permite razonar sobre la complejidad utilizando herramientas estándar de análisis de datos.
“Split into smaller pure functions”,
“Replace deep nesting with guard clauses”,
“Extract complex boolean predicates”
]
si complejidad >= 12: regresar [
“Extract inner logic into helpers”,
“Flatten conditionals”,
“Use dispatch tables”
]
si complejidad >= 8: regresar [
“Reduce nesting”,
“Early returns”
]
devolver [“Acceptable complexity”]
si “complejidad” en fn_df.columns y “función” en fn_df.columns: para _, r en fn_df.sort_values(“complejidad”, ascendente=False).head(8).iterrows(): cx = float(r[“complexity”]) si pd.notna(r[“complexity”]) más Ninguno si cx es Ninguno: continuar print(r[“function”]cx, refactor_hints(cx)) print(“✅ Tutorial completo.”)
Visualizamos la distribución de la complejidad cognitiva y derivamos orientación de refactorización a partir de umbrales numéricos. Traducimos puntuaciones de complejidad abstracta en acciones de ingeniería concretas. Cierra el círculo al conectar la medición directamente con las decisiones de mantenibilidad.
En conclusión, presentamos un proceso práctico y reproducible para auditar la complejidad cognitiva en proyectos de Python utilizando complexipy. Demostramos cómo podemos pasar de una inspección ad hoc a un razonamiento basado en datos sobre la estructura del código, identificar funciones de alto riesgo y proporcionar orientación práctica de refactorización basada en umbrales cuantificados. El flujo de trabajo nos permite razonar sobre la mantenibilidad desde el principio, aplicar presupuestos de complejidad de manera consistente y desarrollar bases de código con claridad y confianza, en lugar de depender únicamente de la intuición.
Consulta los CÓDIGOS COMPLETOS aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.