---
name: render_automatic_eda
kind: pipeline
lang: py
domain: pipelines
purity: impure
version: "1.2.0"
signature: "def render_automatic_eda(db_path: str, table: str, backend: str = \"duckdb\", sample: int = None, run_models: bool = None, run_series: bool = None, run_llm: bool = None, profile_level: str = \"standard\", out_dir: str = \"reports\", basename: str = None, ctx_extra: dict = None, emit_md: bool = True, only_chapters: list = None) -> dict"
description: "Informe AutomaticEDA COMPLETO one-shot de una tabla DuckDB/PostgreSQL: perfila con profile_table, construye el ctx con los datos crudos (build_eda_render_ctx: raw_numeric para modelos/geo, timeseries_raw para series, geo_points para el mapa, db_path/table para la agregacion push-down) y emite PDF (A5 movil) Y PPTX (16:9) del mismo documento por capitulos, con los 11 capitulos POBLADOS de verdad (clusters pintados sobre el PCA, evolucion temporal, mapa geografico y tablas de agregacion), no degradados. El parametro profile_level es un preset de consumo CPU/LLM (lite/standard/full) que mapea a los flags run_models/run_series/run_llm/sample; un flag explicito siempre prima sobre el preset. lite=bajo consumo (sin LLM, sin serie, modelos solo PCA+normalidad sin KMeans/IsolationForest, sample reducido); standard=comportamiento historico; full=standard+narrativa LLM. Devuelve las rutas de PDF/PPTX y el manifiesto de versiones por capitulo."
tags: [eda, duckdb, postgres, profiling, pipeline, dataops, report, pdf, pptx]
uses_functions:
  - profile_table_py_pipelines
  - build_eda_render_ctx_py_datascience
  - render_automatic_eda_pdf_py_datascience
  - render_automatic_eda_pptx_py_datascience
uses_types: []
returns: []
returns_optional: false
error_type: error_go_core
imports: []
tested: true
tests:
  - "render end-to-end sobre DuckDB sintetico con categoricas + fecha + lat/lon emite PDF y PPTX con paginas/slides"
test_file_path: "python/functions/pipelines/render_automatic_eda_test.py"
file_path: "python/functions/pipelines/render_automatic_eda.py"
params:
  - name: db_path
    desc: "Ruta al archivo DuckDB (read-only, debe existir) o DSN PostgreSQL si backend='postgres'."
  - name: table
    desc: "Nombre de la tabla a perfilar e informar."
  - name: backend
    desc: "'duckdb' (default) o 'postgres'. Selecciona el motor de perfilado y muestreo."
  - name: sample
    desc: "Maximo de filas/valores muestreados por columna para el perfil y para los datos crudos del ctx (LIMIT). Default None => lo fija el preset de profile_level (lite=2000, standard/full=5000). Un valor explicito prima sobre el preset."
  - name: run_models
    desc: "Corre los modelos baratos (PCA/KMeans/IsolationForest/normalidad); necesario para que el capitulo modelos pinte los clusters sobre el plano PCA. Default None => lo fija el preset (True en los tres niveles); en lite los modelos se limitan a PCA+normalidad. Un valor explicito prima sobre el preset."
  - name: run_series
    desc: "Calcula el analisis de serie temporal por columna numerica; necesario para el analisis del capitulo timeseries. Default None => lo fija el preset (standard/full=True, lite=False). Un valor explicito prima sobre el preset."
  - name: run_llm
    desc: "Hace la interpretacion LLM del perfil y ACTIVA la narrativa LLM de los capitulos modelos/geospatial/agregacion (titulos de segmento, descripcion de zona, seleccion de agregaciones). Con False usan su derivacion cuantitativa sin red. Default None => lo fija el preset (full=True, lite/standard=False). Un valor explicito prima sobre el preset."
  - name: profile_level
    desc: "Preset de consumo CPU/LLM (default 'standard'). Mapea a defaults de run_models/run_series/run_llm/sample; un flag explicito SIEMPRE prima. 'lite'=bajo consumo (run_llm=False, run_series=False, sample=2000, modelos solo PCA+normalidad sin KMeans/IsolationForest); 'standard'=comportamiento historico (modelos completos, serie, sin LLM); 'full'=standard+narrativa LLM. Un nivel desconocido cae a 'standard'."
  - name: out_dir
    desc: "Directorio de salida (se crea si no existe). Default 'reports'."
  - name: basename
    desc: "Nombre base de los archivos sin extension. Default 'aeda_<table>_<timestamp>'."
  - name: ctx_extra
    desc: "Dict opcional con claves de presentacion/contexto extra que se mezclan en el ctx (dataset_name, description, source_origin, ...); no pisan las claves de datos calculadas por build_eda_render_ctx."
  - name: emit_md
    desc: "Ademas del PDF y el PPTX, emite un Markdown autocontenido del mismo documento por capitulos (texto + tablas markdown, sin binarios) para pegar a un LLM. Default True. La ruta sale en aeda_md_path."
  - name: only_chapters
    desc: "Lista opcional de ids de capitulo a renderizar (subconjunto de CHAPTER_ORDER) para iterar/testear un capitulo suelto sin generar el documento entero. Default None => documento COMPLETO (retrocompatible). Cuando se pasa una lista: (1) se VALIDA contra CHAPTER_ORDER, un id desconocido o lista vacia devuelve error claro listando los validos; (2) se RESUELVEN las dependencias de computo de esos capitulos (automatic_eda.chapter_deps) activando los flags que necesiten (run_models/run_series/run_llm) aunque el caller no los pidiera y construyendo SOLO las piezas de ctx que leen, de modo que el capitulo suelto SIEMPRE llega poblado (p.ej. ['outliers'] activa run_models y conserva raw_numeric -> Isolation Forest completo) sin malgastar CPU/LLM en lo que ningun capitulo pedido usa; (3) el documento y su manifest contienen SOLO esos capitulos MAS portada (primera) y glosario (ultima, cuando hay terminos clicables). Un flag explicito del caller prima sobre la resolucion de dependencias."
output: "dict {status:'ok', pdf_path:str, pptx_path:str, manifest_path:str|None, n_pages:int, n_slides:int, pdf_note:str, pptx_note:str, profile:<TableProfile>} o {status:'error', error:str} (dict-no-throw)."
---

## Ejemplo

```python
from pipelines.render_automatic_eda import render_automatic_eda

# Informe completo a reports/ (standard = comportamiento por defecto historico).
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas", out_dir="reports")
print(r["status"], r["pdf_path"], r["pptx_path"], r["n_pages"], r["n_slides"])
# ok reports/aeda_ventas_20260630-120500.pdf reports/aeda_ventas_20260630-120500.pptx 37 39

# Bajo consumo (CPU/LLM): vistazo rapido y barato — sin LLM, sin serie, modelos
# solo PCA + normalidad (sin KMeans/IsolationForest), sample reducido.
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas", profile_level="lite")

# Maximo: standard + narrativa LLM por capitulo (titulos de segmento, etc.).
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas", profile_level="full")

# Precedencia: el flag explicito SIEMPRE prima sobre el preset. lite pero con LLM:
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas",
                         profile_level="lite", run_llm=True)  # el LLM SI se ejecuta

# Capitulo SUELTO: itera/testea un capitulo sin generar el documento entero. La
# resolucion de dependencias activa el computo que el capitulo necesita aunque no
# se pase explicito. Pedir solo 'outliers' activa run_models y conserva
# raw_numeric -> el bloque Isolation Forest sale COMPLETO. Documento = portada +
# outliers + glosario.
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas", only_chapters=["outliers"])

# Varios capitulos sueltos a la vez (se unen sus dependencias):
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas",
                         only_chapters=["correlacion", "missingness"])

# id desconocido -> error claro listando los validos (dict-no-throw, no lanza):
r = render_automatic_eda("/tmp/ventas.duckdb", "ventas", only_chapters=["nope"])
# {'status': 'error', 'error': 'only_chapters con ids desconocidos: nope. Capitulos validos: portada, overview, ...'}
```

## Cuando usarla

Cuando quieras el informe AutomaticEDA COMPLETO (PDF + PPTX) de una tabla en una
sola llamada, con los capitulos de modelos, series, geoespacial y agregacion ya
poblados (no degradados). Es el reemplazo de "perfila + monta el ctx a mano +
llama a los dos renderers": este pipeline orquesta `profile_table` ->
`build_eda_render_ctx` -> `render_automatic_eda_pdf`/`_pptx`. Usalo como
entregable para compartir un EDA, o como el motor detras de `profile_table(
emit_automatic=True)` y del skill `/eda`.

Para un EDA **barato/rapido** (CI, vistazo previo, maquina sin GPU o sin red) usa
`profile_level="lite"`: evita KMeans + IsolationForest (lo caro en CPU), la serie
temporal y el LLM. Para el **maximo** con interpretacion narrativa por capitulo,
`profile_level="full"`. El default `"standard"` mantiene el comportamiento previo.

Cuando estes **iterando o testeando UN capitulo concreto** (afinar el render de
outliers, comprobar el mapa geoespacial, depurar la agregacion) usa
`only_chapters=[...]`: genera el documento con solo esos capitulos (+ portada y
glosario), pero **resuelve sus dependencias de computo** para que el capitulo
suelto nunca salga degradado — pedir `['outliers']` activa run_models y conserva
`raw_numeric` aunque no los pases, y a la vez no malgasta CPU/LLM en lo que ningun
capitulo pedido necesita (pedir `['geospatial']` no corre modelos). Es mucho mas
rapido que renderizar el informe entero en cada iteracion. El mapa central de
dependencias vive en `automatic_eda/chapter_deps.py` (fuente de verdad).

## Gotchas

- Impura: ESCRIBE el PDF, el PPTX y `automatic_eda_manifest.json` en `out_dir`.
- `db_path` debe existir: DuckDB read-only no crea la base.
- **Precedencia de flags vs preset**: `profile_level` solo fija los DEFAULTS de
  `run_models`/`run_series`/`run_llm`/`sample` (los que quedan en None). Cualquiera
  de esos flags pasado explicito gana al preset. Ej: `profile_level="lite",
  run_llm=True` ejecuta el LLM pese a que lite lo apaga por defecto.
- **lite y la seleccion de features de modelo**: en lite los modelos (PCA +
  normalidad) corren sobre la muestra numerica cruda (`ctx['raw_numeric']`), sin la
  poda fina de features que aplica el modo standard (que excluye ids enteros y
  columnas de baja cardinalidad antes de PCA/KMeans). Es el coste de mantener el
  cableado minimo y barato; para el analisis fino de modelos usa standard/full.
- `profile_level="standard"`/`"full"` corren PCA/KMeans/IsolationForest +
  ADF/KPSS/STL por columna (caro). Para un informe mas barato usa `"lite"` (o pon
  los flags a False a mano): los capitulos modelos/timeseries se reducen pero el
  resto del informe sale igual.
- `run_llm=True` (preset full o flag explicito) hace llamadas de red
  (interpretacion del perfil + narrativa por capitulo). Sin red, usa lite/standard:
  los capitulos siguen completos con su derivacion cuantitativa.
- El PPTX requiere `python-pptx`; si no esta instalado, `pptx_path` sera None y
  `pptx_note` lo explica (el PDF se emite igual).
- Los datos crudos del ctx se muestrean con `sample` (LIMIT), no se trae la tabla
  entera a RAM; con tablas enormes sube `sample` si quieres mas representatividad
  (coste: mas memoria).
- **`only_chapters` y el glosario**: el glosario (ultimo capitulo) solo aparece si
  algun capitulo del cuerpo registro terminos clicables. Un capitulo suelto que no
  registra terminos (p.ej. `timeseries`, `geospatial`) sale como portada + ese
  capitulo, sin glosario, porque no hay nada que enlazar — es correcto, no un fallo.
- **`only_chapters` con `profile_level="lite"`**: en capitulos sueltos el preset
  solo gobierna `sample`; los modelos NO usan el camino "lite" (que podaria
  `ctx['raw_numeric']` y dejaria a outliers sin su multivariante en vivo). Quien
  manda en capitulos sueltos es la resolucion de dependencias, no el preset de
  coste de modelos.

## Capability growth log

- v1.2.0 (2026-06-30) — anade el parametro `only_chapters`: renderiza un
  SUBCONJUNTO de capitulos (para iterar/testear uno suelto) resolviendo sus
  dependencias de computo via `automatic_eda/chapter_deps.py` (mapa central
  CHAPTER_DEPS): activa los flags de coste que el capitulo necesita (run_models/
  run_series/run_llm) aunque el caller no los pase y construye solo las piezas de
  ctx que lee, de modo que el capitulo suelto SIEMPRE llega poblado (golden:
  ['outliers'] -> Isolation Forest completo) sin malgastar en lo que no usa. La
  seleccion viaja a build_document por la clave reservada `ctx['_only_chapters']`
  (los renderers no cambian). Valida ids (error claro dict-no-throw). Cambio
  aditivo y retro-compatible: `only_chapters=None` produce el documento completo
  identico a v1.1.0.
- v1.1.0 (2026-06-30) — anade el parametro `profile_level` (lite/standard/full),
  preset de consumo CPU/LLM que mapea a los flags run_models/run_series/run_llm/
  sample. lite limita los modelos a PCA+normalidad (cableado a run_eda_models con
  run_kmeans=False/run_isolation=False) y apaga LLM/serie. Cambio aditivo y
  retro-compatible: sin profile_level el comportamiento es identico al de v1.0.0.
