dane-data 0.2.1__py3-none-any.whl

dane_data/app/paginas/descargar.py

@@ -0,0 +1,101 @@
+import logging
+
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import LogEnPantalla, disponibles_eam, disponibles_geih, rutas_actuales
+
+st.title("⬇️ Descargar datos del DANE")
+st.markdown(
+    "Los archivos se bajan del **Archivo Nacional de Datos (ANDA)** del DANE y se guardan en su computador. "
+    "La descarga es **incremental**: si se interrumpe, al repetirla continúa donde iba."
+)
+
+encuesta = st.radio("Encuesta", ["GEIH (hogares, mensual)", "EAM (industria, anual)"], horizontal=True)
+rutas = rutas_actuales()
+
+if encuesta.startswith("GEIH"):
+    serie = st.radio("Serie", ["Principal (2007–2026)", "Empalme (2010–2020)"], horizontal=True,
+                     help="El empalme re-pondera 2010–2020 con el censo 2018 para empalmar con 2021 en adelante.")
+    empalme = serie.startswith("Empalme")
+    anios_ok = dd.geih.ANIOS_EMPALME if empalme else dd.geih.ANIOS_DISPONIBLES
+    ya = disponibles_geih(empalme, rutas)
+    tiene = set(ya.anio.unique()) if len(ya) else set()
+    anios = st.multiselect("Años", anios_ok, default=[anios_ok[-1]],
+                           format_func=lambda a: f"{a} ✓" if a in tiene else str(a))
+    st.caption("✓ = ya descargado (total o parcialmente).")
+    NOMBRES = {
+        "caracteristicas": "Características generales (edad, sexo, educación, salud)",
+        "fuerza_trabajo": "Fuerza de trabajo",
+        "ocupados": "Ocupados (empleo, ingresos, formalidad)",
+        "desocupados": "Desocupados",
+        "inactivos": "Inactivos",
+        "vivienda": "Vivienda y hogar",
+        "otras_formas_trabajo": "Otras formas de trabajo",
+    }
+    with st.expander("Opciones avanzadas"):
+        modulos = st.multiselect("Módulos", list(NOMBRES), default=list(NOMBRES), format_func=NOMBRES.get,
+                                 help="Para los indicadores laborales se necesitan al menos: características, "
+                                      "fuerza de trabajo, ocupados y desocupados.")
+        prueba = st.toggle("Solo el primer mes de cada año (para probar)")
+        borrar = st.toggle("Borrar los ZIP después de extraer (ahorra ~40 % de espacio)", value=True)
+    st.info(f"📦 Tamaño aproximado: **{0.6 * len(anios) if not prueba else 0.05 * len(anios):.1f} GB** · "
+            f"destino: `{dd.get_path('geih_empalme' if empalme else 'geih')}`")
+    lanzar = lambda prog, stop: dd.geih.download(  # noqa: E731
+        anios, modules=modulos, empalme=empalme, delete_zips=borrar, limit_files=1 if prueba else None,
+        progress=prog, should_stop=stop)
+    codigo_py = (f"dd.geih.download({anios!r}" + (", empalme=True" if empalme else "")
+                 + (", limit_files=1" if prueba else "") + ")")
+else:
+    ya = disponibles_eam(rutas)
+    tiene = set(ya.anio.unique()) if len(ya) else set()
+    todos = dd.eam.ANIOS_DISPONIBLES
+    faltan = [a for a in todos if a not in tiene]
+    # Valor inicial por session_state (no `default`) para que el botón de abajo pueda
+    # cambiar la selección: un `if st.button(...)` la perdía al pulsar "Descargar".
+    if "descargar_eam_anios" not in st.session_state:
+        st.session_state["descargar_eam_anios"] = faltan[-5:]
+    anios = st.multiselect("Años", todos, key="descargar_eam_anios",
+                           format_func=lambda a: f"{a} ✓" if a in tiene else str(a))
+    c1, c2 = st.columns(2)
+    c1.button("Seleccionar toda la serie 1992–2024",
+              on_click=lambda: st.session_state.update(descargar_eam_anios=list(todos)))
+    tic = st.toggle("Incluir módulo de TIC (2008–2018)")
+    borrar = st.toggle("Borrar los ZIP después de extraer", value=True)
+    st.info(f"📦 Tamaño aproximado: **{10 * len(anios)} MB** · destino: `{dd.get_path('eam')}`")
+    lanzar = lambda prog, stop: dd.eam.download(anios, include_tic=tic, delete_zips=borrar,  # noqa: E731
+                                                progress=prog, should_stop=stop)
+    codigo_py = f"dd.eam.download({anios!r})"
+
+if st.button("⬇️ Descargar", type="primary", disabled=not anios):
+    barra = st.progress(0.0, text="Conectando con el DANE…")
+    detalle = st.empty()
+    logs = st.empty()
+    handler = LogEnPantalla(logs)
+    logger = logging.getLogger("dane_data")
+    logger.setLevel(logging.INFO)
+    logger.addHandler(handler)
+    estado = {"f": 0.0}
+
+    def progreso(f, msg):
+        if f is not None:
+            estado["f"] = f
+            barra.progress(min(f, 1.0), text=msg)
+        else:
+            detalle.caption(msg)
+
+    try:
+        with st.spinner("Descargando… (puede tardar varios minutos; para cancelar use **Stop** arriba a la derecha)"):
+            lanzar(progreso, None)
+        barra.progress(1.0, text="¡Listo!")
+        st.success("Descarga terminada. Ya puede analizar los datos en las demás páginas.")
+        st.cache_data.clear()
+        st.cache_resource.clear()
+    except Exception as e:  # noqa: BLE001
+        st.error(f"La descarga falló: {e}. Revise su conexión e intente de nuevo; lo ya descargado se conserva.")
+    finally:
+        logger.removeHandler(handler)
+
+with st.expander("🐍 Hacerlo desde Python o la terminal"):
+    st.code(f"import dane_data as dd\n{codigo_py}", language="python")
+    st.code("dane-data descargar geih --anios 2024 2025\ndane-data descargar eam --anios 2022 2023 2024", language="bash")

dane_data/app/paginas/diccionario.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import streamlit as st
+
+import dane_data as dd
+
+st.title("📚 Diccionario de variables")
+st.markdown(
+    "Busque variables por código o por palabras de la pregunta. Fuente: metadatos oficiales del DANE "
+    "(GEIH 2025 y EAM 2024). Los nombres pueden variar en años antiguos."
+)
+
+c1, c2 = st.columns([1, 3])
+encuesta = c1.radio("Encuesta", ["GEIH", "EAM"], horizontal=True)
+texto = c2.text_input("Buscar", placeholder="p. ej. pensión, arriendo, horas, salarios, P6920")
+
+res = dd.buscar_variable(texto or "", encuesta.lower())
+st.caption(f"{len(res)} variables")
+evento = st.dataframe(res, hide_index=True, width="stretch", on_select="rerun", selection_mode="single-row",
+                      column_config={"pregunta": st.column_config.TextColumn(width="large")})
+
+filas = evento.selection.rows if evento and evento.selection else []
+if filas:
+    var = res.iloc[filas[0]]["variable"]
+    info = dd.diccionario(encuesta.lower())[var]
+    st.subheader(var)
+    st.markdown(f"**{info['etiqueta']}**")
+    if info["pregunta"] and info["pregunta"] != info["etiqueta"]:
+        st.markdown(f"> {info['pregunta']}")
+    if info.get("modulos"):
+        st.caption("Módulo(s): " + ", ".join(m.replace(".NSDstat", "") for m in info["modulos"]))
+    if info["categorias"]:
+        st.markdown("**Categorías**")
+        st.dataframe(pd.DataFrame(list(info["categorias"].items()), columns=["código", "significado"]),
+                     hide_index=True)
+    st.code(f'df = dd.{encuesta.lower()}.load(2024, columns=["{var if encuesta == "GEIH" else var.lower()}"])',
+            language="python")
+else:
+    st.caption("👆 Seleccione una fila para ver sus categorías.")
+
+with st.expander("Variables armonizadas por dane-data (iguales en todos los años)"):
+    if encuesta == "GEIH":
+        st.markdown("""
+| Variable | Descripción |
+|---|---|
+| `anio`, `mes` | Año y mes de la encuesta |
+| `fex` | Factor de expansión mensual (FEX_C18 / FEX_C / FEX_C_2011 según la época) |
+| `sexo`, `edad`, `grupo_edad` | Sexo (P3271 o P6020), edad (P6040) y grupos de edad |
+| `departamento`, `dpto`, `zona` | Departamento y zona urbana/rural (CLASE) |
+| `condicion` | Ocupado / Desocupado / Inactivo / Fuera de la PET |
+| `pet`, `fuerza_trabajo`, `ocupado`, `desocupado`, `inactivo` | Indicadoras 0/1 |
+| `formal` | 1 si el ocupado está afiliado a salud (P6090) y cotiza a pensión (P6920) |
+| `ingreso_laboral`, `ratio_smlv`, `smlv` | INGLABO, su razón frente al salario mínimo y el salario mínimo del año |
+| `horas_semana` | Horas trabajadas normalmente (P6800) |
+| `posicion_ocupacional` | P6430 con etiquetas |
+| `nivel_educativo` | Ninguno / Primaria / Secundaria / Media / Superior (P3042 o P6210) |
+| `rama2d`, `rama_rev` | Rama de actividad a 2 dígitos y su revisión CIIU (3 o 4) |
+""")
+    else:
+        st.dataframe([{"variable": k, "descripción": v} for k, v in dd.eam.ETIQUETAS.items()]
+                     + [{"variable": "ciiu / ciiu_rev", "descripción": "Código CIIU y su revisión (2, 3 o 4)"},
+                        {"variable": "division / sector", "descripción": "CIIU a 2 dígitos y su nombre"},
+                        {"variable": "departamento", "descripción": "Nombre del departamento"}], hide_index=True)

dane_data/app/paginas/eam_industria.py

@@ -0,0 +1,129 @@
+import pandas as pd
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import (MAX_SERIES, barras, botones_descarga, codigo, fmt_num, fmt_pct, grafico,
+                             linea, selector_eam)
+
+st.title("🏭 Indicadores de la industria manufacturera")
+eam, descripcion, params = selector_eam(clave="eam")
+st.caption(f"**Datos:** EAM {descripcion} · {fmt_num(len(eam))} registros establecimiento-año")
+
+VARIABLES = {
+    "Valor agregado": ("valor_agregado", "monetaria"),
+    "Producción bruta": ("produccion_bruta", "monetaria"),
+    "Personal ocupado total": ("personal_total", "personas"),
+    "Productividad laboral (VA por persona)": ("productividad_laboral", "monetaria"),
+    "Remuneración media por empleado": ("remuneracion_media", "monetaria"),
+    "Participación laboral en el VA (%)": ("participacion_laboral", "pct"),
+    "Valor agregado / producción (%)": ("tasa_valor_agregado", "pct"),
+    "Número de establecimientos": ("establecimientos", "conteo"),
+    "Inversión bruta": ("inversion_bruta", "monetaria"),
+    "Activos fijos": ("activos_fijos", "monetaria"),
+    "Energía eléctrica (kWh)": ("energia_kwh", "conteo"),
+}
+DESAGREGAR = {"Total industria": None, "Sector (división CIIU)": "sector", "Departamento": "departamento"}
+
+# ---------------------------------------------------------------- KPIs
+tot = dd.eam.resumen(eam, por="anio")
+u = tot.iloc[-1]
+p = tot.iloc[-2] if len(tot) > 1 else None
+
+
+def var(col, pp=False):
+    if p is None or pd.isna(p[col]) or p[col] == 0:
+        return None
+    return f"{u[col] - p[col]:+.1f} p.p." if pp else f"{100 * (u[col] / p[col] - 1):+.1f} % vs {int(p['anio'])}"
+
+
+st.markdown(f"##### Resumen {int(u['anio'])}")
+k = st.columns(5)
+k[0].metric("Establecimientos", fmt_num(u.establecimientos), var("establecimientos"))
+k[1].metric("Personal ocupado", fmt_num(u.personal_total), var("personal_total"))
+k[2].metric("Valor agregado (billones $)", fmt_num(u.valor_agregado / 1e9, 1), var("valor_agregado"),
+            help="Pesos corrientes. Los microdatos de la EAM vienen en miles de pesos.")
+k[3].metric("Productividad (millones $/persona)", fmt_num(u.productividad_laboral / 1e3, 1), var("productividad_laboral"),
+            help=dd.eam.GLOSARIO["Productividad laboral"])
+k[4].metric("Participación laboral", fmt_pct(u.participacion_laboral), var("participacion_laboral", pp=True),
+            help=dd.eam.GLOSARIO["Participación laboral"])
+st.divider()
+
+# ---------------------------------------------------------------- Gráfico
+c1, c2, c3 = st.columns([2, 2, 1.3])
+nombre_var = c1.selectbox("Variable", list(VARIABLES))
+nombre_por = c2.selectbox("Desagregar por", list(DESAGREGAR))
+vista = c3.radio("Vista", ["Evolución", "Un año"], horizontal=True)
+col, tipo = VARIABLES[nombre_var]
+por = DESAGREGAR[nombre_por]
+
+res = dd.eam.resumen(eam, por=["anio"] + ([por] if por else []))
+# Escala para graficar: los microdatos vienen en miles de pesos.
+POR_PERSONA = ("productividad_laboral", "remuneracion_media")
+if tipo == "monetaria":
+    div, unidad = (1e3, "millones de $ por persona") if col in POR_PERSONA else (1e6, "miles de millones de $")
+    res["_y"] = res[col] / div
+else:
+    unidad = None
+    res["_y"] = res[col]
+if por:
+    res = res[res[por].notna()]
+    revs = eam.groupby("anio")["ciiu_rev"].first().nunique()
+    if por == "sector" and revs > 1 and vista == "Evolución":
+        st.warning("⚠️ Los años elegidos mezclan revisiones de la CIIU: los sectores cambian de definición y "
+                   "las series se cortan. Elija años de una sola revisión (p. ej. 2012 en adelante).")
+
+if vista == "Evolución":
+    indice = False
+    if tipo == "monetaria":
+        indice = st.toggle("Ver como índice (primer año = 100)",
+                           help="Los valores están en pesos corrientes: incluyen inflación. El índice facilita "
+                                "comparar crecimientos entre grupos de distinto tamaño.")
+    g = res.copy()
+    if por and g[por].nunique() > MAX_SERIES:
+        orden = g.groupby(por)[col].sum().sort_values(ascending=False).index.tolist()
+        elegidos = st.multiselect(f"Hay {len(orden)} grupos; elija hasta {MAX_SERIES}", orden, default=orden[:5],
+                                  max_selections=MAX_SERIES)
+        g = g[g[por].isin(elegidos)]
+    y, titulo = "_y", nombre_var + (f" ({unidad})" if unidad else "")
+    if indice:
+        base = g.sort_values("anio").groupby(por)[col].transform("first") if por else g[col].iloc[0]
+        g["indice"] = 100 * g[col] / base
+        y, titulo = "indice", f"{nombre_var} (índice, {g['anio'].min()} = 100)"
+    grafico(linea(g, x="anio", y=y, color=por, titulo_y=titulo, pct=tipo == "pct"))
+else:
+    anio = st.select_slider("Año", sorted(res["anio"].unique()), value=res["anio"].max())
+    g = res[res["anio"] == anio]
+    if por:
+        grafico(barras(g, x=por, y="_y", titulo_y=nombre_var + (f" ({unidad})" if unidad else ""),
+                       pct=tipo == "pct", horizontal=True))
+        if tipo in ("monetaria", "personas", "conteo") and col not in ("productividad_laboral", "remuneracion_media"):
+            top = g.sort_values(col, ascending=False).head(3)
+            share = 100 * top[col].sum() / g[col].sum()
+            st.caption(f"Los 3 primeros ({', '.join(top[por].astype(str))}) concentran el **{fmt_pct(share)}** "
+                       f"del total en {anio}.")
+    else:
+        v = g[col].iloc[0]
+        st.metric(nombre_var + (f" ({unidad})" if unidad else ""),
+                  fmt_pct(v) if tipo == "pct" else fmt_num(g["_y"].iloc[0], 1))
+
+if tipo == "monetaria":
+    st.caption("💡 Valores en **pesos corrientes**: incluyen inflación (los microdatos vienen en miles de pesos). Para comparar en términos reales use un deflactor "
+               "(IPP o deflactor del PIB) con `dd.eam.deflactar` en Python.")
+
+with st.expander("📋 Tabla completa"):
+    res = res.drop(columns="_y")
+    st.dataframe(res, hide_index=True, width="stretch",
+                 column_config={"anio": st.column_config.NumberColumn("Año", format="%d")})
+    botones_descarga(res, f"resumen_eam_{params['anios'][0]}_{params['anios'][-1]}", "eamres")
+
+with st.expander("📖 Glosario"):
+    for k_, v in dd.eam.GLOSARIO.items():
+        st.markdown(f"**{k_}.** {v}")
+
+codigo(f'''
+import dane_data as dd
+
+{params["carga"]}
+res = dd.eam.resumen(eam, por={["anio"] + ([por] if por else [])!r})
+res
+''')

dane_data/app/paginas/eam_microdatos.py

@@ -0,0 +1,56 @@
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import fmt_num, barras, botones_descarga, codigo, grafico, linea, selector_eam
+
+st.title("🧱 Panel y microdatos EAM")
+
+dic = dd.diccionario("eam")
+with st.sidebar:
+    extra = st.multiselect(
+        "Variables DANE adicionales", sorted(v.lower() for v in dic if v.lower() not in dd.eam.CORE),
+        key="eamm_extra", format_func=lambda v: f"{v} — {dic.get(v.upper(), {}).get('etiqueta', '')[:60]}",
+        help="Por ejemplo c3r10c1 (sueldos de obreros) o c4r5c1. Nombres del diccionario 2024; "
+             "muchas variables de capítulo cambian de nombre entre épocas.",
+    )
+eam, descripcion, params = selector_eam(extra=tuple(extra), clave="eamm")
+st.caption(f"**Datos:** EAM {descripcion} · {fmt_num(len(eam))} registros")
+
+tab1, tab2 = st.tabs(["🔁 Panel de establecimientos", "🗂️ Microdatos"])
+
+with tab1:
+    st.markdown(
+        "Cada establecimiento tiene un identificador (`nordest`) que se repite año tras año, lo que permite "
+        "construir un **panel**. Un panel **balanceado** conserva solo las plantas observadas en *todos* los años."
+    )
+    sup = dd.eam.supervivencia(eam)
+    if len(sup):
+        grafico(linea(sup, x="anio", y="pct_siguen", titulo_y="% que reaparece al año siguiente", pct=True))
+        st.caption("Caídas bruscas suelen indicar cambios de identificador o de cobertura, no cierres reales.")
+    bal = st.toggle("Panel balanceado")
+    pan = dd.eam.panel(eam, balanceado=bal)
+    n_est = pan.index.get_level_values("nordest").nunique()
+    c = st.columns(3)
+    c[0].metric("Establecimientos", f"{n_est:,}".replace(",", "."))
+    c[1].metric("Años", pan.index.get_level_values("anio").nunique())
+    c[2].metric("Observaciones", f"{fmt_num(len(pan))}")
+    por_anio = pan.reset_index().groupby("anio").size().rename("establecimientos").reset_index()
+    grafico(barras(por_anio, x="anio", y="establecimientos", titulo_y="Establecimientos"))
+    if st.toggle("Preparar panel para descargar", key="pan_dl"):
+        botones_descarga(pan.reset_index(), f"panel_eam{'_balanceado' if bal else ''}", "pan")
+    codigo(f'''
+import dane_data as dd
+
+{params["carga"]}
+panel = dd.eam.panel(eam, balanceado={bal})   # índice (nordest, anio), listo para linearmodels/statsmodels
+dd.eam.supervivencia(eam)
+''')
+
+with tab2:
+    st.markdown("Variables armonizadas: `anio`, `ciiu`, `ciiu_rev`, `division`, `sector`, `departamento`. "
+                "El resto son las originales del DANE en minúscula.")
+    with st.expander("¿Qué significa cada variable?"):
+        st.dataframe([{"variable": k, "descripción": v} for k, v in dd.eam.ETIQUETAS.items()], hide_index=True)
+    st.dataframe(eam.head(1000), hide_index=True, width="stretch")
+    if st.toggle("Preparar archivos para descargar", key="micro_dl"):
+        botones_descarga(eam, "microdatos_eam", "eammicro")

dane_data/app/paginas/geih_explorar.py

@@ -0,0 +1,219 @@
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import (fmt_num, MAX_SERIES, PALETA, _barra, _estilo, args_py, barras, botones_descarga,
+                             codigo, fmt_pct, fmt_pesos, frecuencias_geih, grafico, muestra_geih, rutas_actuales,
+                             seleccion_geih, tabla_geih)
+
+st.title("🔎 Tablas y microdatos GEIH")
+
+POBLACIONES = {
+    "Toda la población": None,
+    "En edad de trabajar (PET)": "pet",
+    "Fuerza de trabajo": "fuerza_trabajo",
+    "Ocupados": "ocupado",
+    "Desocupados": "desocupado",
+    "Inactivos": "inactivo",
+}
+CATEGORICAS = {
+    "Año": "anio", "Mes": "mes", "Sexo": "sexo", "Zona": "zona", "Grupo de edad": "grupo_edad",
+    "Nivel educativo": "nivel_educativo", "Departamento": "departamento",
+    "Condición de actividad": "condicion", "Posición ocupacional": "posicion_ocupacional",
+    "Formal (seguridad social)": "formal", "Jefe de hogar": "jefe_hogar",
+    "Rama de actividad (2 díg.)": "rama2d",
+}
+NUMERICAS = {
+    "Ingreso laboral": "ingreso_laboral", "Ingreso / salario mínimo": "ratio_smlv",
+    "Horas trabajadas por semana": "horas_semana", "Edad": "edad",
+}
+
+# Variables DANE adicionales: las del diccionario 2025 y las que dane-data lee siempre (CORE_RAW)
+dic = dd.diccionario("geih")
+
+
+def etiqueta(v: str, largo: int) -> str:
+    return f"{v} — {dic.get(v, {}).get('etiqueta', '')[:largo]}"
+
+
+with st.sidebar:
+    extra = st.multiselect(
+        "Variables DANE adicionales", sorted(set(dic) | set(dd.geih.CORE_RAW)), key="exp_extra",
+        format_func=lambda v: etiqueta(v, 60),
+        help="Busque por código o por texto de la pregunta (p. ej. 'arriendo', 'P6500'). "
+             "Nombres según el diccionario 2025; en años antiguos algunas no existen.",
+    )
+sel = seleccion_geih(clave="exp")
+anios = tuple(sel["anios"])
+# Las variables de CORE_RAW se leen siempre: pedirlas en `columns` solo crearía otra caché.
+columnas = tuple(sorted(e for e in extra if e not in dd.geih.CORE_RAW))
+# Todas las tablas salen de dd.geih.serie_*: año por año y guardadas en disco, nunca todos los años en memoria.
+comunes = dict(filtros=sel["filtros"], meses=tuple(sel["meses"]) if sel["meses"] else None, columnas=columnas,
+               empalme=sel["empalme"], meses_disp=sel["meses_disponibles"], rutas=rutas_actuales())
+args_comunes = args_py(filtros=sel["filtros"], meses=sel["meses"], columns=list(columnas), empalme=sel["empalme"])
+
+pob = st.radio("Población", list(POBLACIONES), horizontal=True, index=3)
+poblacion = POBLACIONES[pob]
+n_total = int(tabla_geih(anios, (), None, "total", poblacion, dropna=False, **comunes)["n_muestra"].sum())
+st.caption(f"**Datos:** {sel['descripcion']} · {pob.lower()} · {fmt_num(n_total)} personas en la muestra")
+if not n_total:
+    st.warning("Ninguna persona cumple los filtros elegidos.")
+    st.stop()
+
+# Un solo mes de microdatos: para saber el tipo de las variables adicionales y para la vista previa.
+anio_m, mes_m = next((a, m) for a, m in sel["meses_disponibles"] if not sel["meses"] or m in sel["meses"])
+variables = list(dict.fromkeys(["fex", *filter(None, POBLACIONES.values()), *CATEGORICAS.values(),
+                                *NUMERICAS.values(), *extra]))
+muestra = dd.geih.filtrar(muestra_geih(anio_m, mes_m, tuple(variables), columnas, sel["empalme"], rutas_actuales()),
+                          sel["filtros"], poblacion)
+for v in extra:
+    if v in muestra.columns:
+        if pd.api.types.is_numeric_dtype(muestra[v]) and muestra[v].nunique() > 15:
+            NUMERICAS[etiqueta(v, 40)] = v
+        else:
+            CATEGORICAS[etiqueta(v, 40)] = v
+
+tab1, tab2, tab3 = st.tabs(["📊 Tabla ponderada", "💰 Ingresos y salario mínimo", "🗂️ Microdatos"])
+
+# ---------------------------------------------------------------- Tabla ponderada
+with tab1:
+    c1, c2, c3 = st.columns(3)
+    estad = c1.selectbox("¿Qué quiere calcular?", ["Distribución (%)", "Número de personas", "Promedio de…",
+                                                    "Mediana de…"])
+    filas = c2.selectbox("Filas", list(CATEGORICAS), index=2)
+    cols_opts = ["(ninguna)"] + [k for k in CATEGORICAS if k != filas]
+    columnas_tabla = c3.selectbox("Columnas / comparar por", cols_opts, index=cols_opts.index("Año"))
+    variable = None
+    if estad in ("Promedio de…", "Mediana de…"):
+        variable = NUMERICAS[st.selectbox("Variable", list(NUMERICAS))]
+
+    f, c = CATEGORICAS[filas], (CATEGORICAS[columnas_tabla] if columnas_tabla != "(ninguna)" else None)
+    por = [c, f] if c else [f]
+    est = {"Distribución (%)": "porcentaje", "Número de personas": "total", "Promedio de…": "media",
+           "Mediana de…": "mediana"}[estad]
+    # dropna: sin las personas con valor vacío en filas o columnas (p. ej. la rama de quien no trabaja)
+    t = tabla_geih(anios, tuple(por), variable, est, poblacion, dropna=True, **comunes)
+
+    if t.empty:
+        st.info("No hay datos para esta combinación (puede ser una variable que esos años no existe).")
+    else:
+        if c:
+            t[c] = t[c].astype(str)
+        t[f] = t[f].astype(str)
+        if c and t[c].nunique() <= MAX_SERIES:
+            fig = barras(t, x=f, y=est, color=c, pct=est == "porcentaje", horizontal=t[f].nunique() > 8)
+        else:
+            fig = barras(t, x=f, y=est, pct=est == "porcentaje", horizontal=t[f].nunique() > 8)
+        grafico(fig)
+
+        if c:
+            pivot = t.pivot(index=f, columns=c, values=est)
+            st.dataframe(pivot.style.format("{:,.1f}" if est == "porcentaje" else "{:,.0f}"), width="stretch")
+        else:
+            st.dataframe(t, hide_index=True, width="stretch")
+        if (t["n_muestra"] < 100).any():
+            st.warning("⚠️ Algunas celdas tienen menos de 100 observaciones: interprételas con cautela.")
+        st.caption("Distribución (%): porcentaje de cada fila dentro de cada columna. Cifras ponderadas con el "
+                   "factor de expansión (promedio mensual).")
+        botones_descarga(t, "tabla_geih", "tab")
+    codigo(f'''
+import dane_data as dd
+
+# Igual a dd.tabla(...) sobre los microdatos filtrados, pero año por año y guardado en caché.
+t = dd.geih.serie_tabla({list(anios)!r}, por={por!r}{args_py(variable=variable)}\
+{f', estadistico="{est}"' if est != "total" else ""}{args_py(poblacion=poblacion)}, dropna=True{args_comunes})
+t
+''')
+
+# ---------------------------------------------------------------- Ingresos
+with tab2:
+    st.markdown("**Ocupados con ingreso laboral** (con los filtros de la barra lateral)")
+    freq = frecuencias_geih(anios, "ingreso_laboral", (), "ocupado", **{**comunes, "columnas": ()})
+    oc = freq[freq["ingreso_laboral"] > 0]
+    if oc.empty:
+        st.info("No hay ocupados con ingreso en la selección (la GEIH 2007 no trae ingresos laborales).")
+    else:
+        w = oc["peso"]
+        r = oc["ingreso_laboral"] / oc["anio"].map(dd.SMLV)
+        tramos = pd.cut(r, [0, 0.5, 0.95, 1.05, 1.22, 1.5, 2, 4, np.inf],
+                        labels=["< 0,5", "0,5–0,95", "≈ 1 (0,95–1,05)", "1,05–1,22", "1,22–1,5", "1,5–2", "2–4",
+                                "4 o más"])
+        dist = (w.groupby(tramos, observed=False).sum() / w.sum() * 100).rename("porcentaje").reset_index()
+        dist.columns = ["Salarios mínimos", "porcentaje"]
+
+        k = st.columns(3)
+        k[0].metric("Ingreso mediano", fmt_pesos(dd.weighted_quantile(oc["ingreso_laboral"], w, 0.5)))
+        k[1].metric("Ganan menos de 1 SMLV", fmt_pct(100 * w[r < 0.95].sum() / w.sum()))
+        k[2].metric("Ganan ≈ 1 SMLV (±5 %)", fmt_pct(100 * w[(r >= 0.95) & (r <= 1.05)].sum() / w.sum()),
+                    help="La acumulación en el mínimo muestra cuánto 'muerde' el salario mínimo.")
+
+        st.markdown("**Distribución de los ocupados según su ingreso en salarios mínimos**")
+        grafico(barras(dist, x="Salarios mínimos", y="porcentaje", titulo_y="% de ocupados", pct=True))
+
+        st.markdown("**Histograma del ingreso / salario mínimo** (hasta 4 SMLV)")
+        hist, edges = np.histogram(r[r <= 4], bins=80, weights=w[r <= 4])
+        fig = go.Figure(go.Bar(x=(edges[:-1] + edges[1:]) / 2, y=100 * hist / w.sum(), marker_color=PALETA[0],
+                               marker_line_width=0,
+                               hovertemplate="%{x:.2f} SMLV: %{y:.2f} %<extra></extra>"))
+        fig.add_vline(x=1, line_dash="dash", line_width=1.5, line_color="gray",
+                      annotation_text="1 salario mínimo", annotation_position="top right")
+        fig = _estilo(fig, "% de ocupados", pct=True)
+        fig.update_layout(bargap=0.05)
+        fig.update_xaxes(title="Ingreso laboral / salario mínimo del año")
+        grafico(fig)
+        st.caption("Salario mínimo usado por año: " +
+                   ", ".join(f"{a}: {fmt_pesos(dd.SMLV.get(a))}" for a in anios))
+        codigo(f'''
+import dane_data as dd
+
+# Distribución ponderada del ingreso de los ocupados (año por año, guardada en caché)
+f = dd.geih.serie_frecuencias({list(anios)!r}, "ingreso_laboral", poblacion="ocupado"\
+{args_py(filtros=sel["filtros"], meses=sel["meses"], empalme=sel["empalme"])})
+f = f[f.ingreso_laboral > 0]
+ratio = f.ingreso_laboral / f.anio.map(dd.SMLV)
+dd.weighted_quantile(f.ingreso_laboral, f.peso, 0.5)    # ingreso mediano
+100 * f.peso[ratio < 0.95].sum() / f.peso.sum()         # % que gana menos de 1 SMLV
+''')
+
+# ---------------------------------------------------------------- Microdatos
+with tab3:
+    st.markdown(f"Vista previa de **{dd.MESES[mes_m]} {anio_m}**, el primer mes de la selección. Las variables en "
+                "**minúscula** son armonizadas por `dane-data`; las de **MAYÚSCULA** son las originales del DANE "
+                "que elija en «Variables DANE adicionales».")
+    armonizadas = ["anio", "mes", "fex", "sexo", "edad", "grupo_edad", "departamento", "zona", "condicion",
+                   "formal", "ingreso_laboral", "ratio_smlv", "horas_semana", "posicion_ocupacional",
+                   "nivel_educativo", "rama2d"]
+    # Las variables adicionales se ofrecen aunque falten en este mes: en otros meses pueden estar.
+    todas = list(dict.fromkeys([*muestra.columns, *extra]))
+    elegidas = st.multiselect("Columnas", todas, default=[c for c in armonizadas + list(extra) if c in todas])
+    st.dataframe(muestra.reindex(columns=elegidas).head(1000), hide_index=True, width="stretch")
+    st.caption(f"{fmt_num(len(muestra))} filas en {dd.MESES[mes_m].lower()} de {anio_m}; "
+               f"{fmt_num(n_total)} en toda la selección.")
+    if st.toggle("Descargar este mes (CSV, Excel o Stata)"):
+        botones_descarga(muestra.reindex(columns=elegidas), f"microdatos_geih_{anio_m}_{mes_m:02d}", "micro")
+
+    st.markdown("**Exportar todos los meses elegidos**")
+    nombre = f"microdatos_geih_{anios[0]}" + (f"_{anios[-1]}" if len(anios) > 1 else "")
+    destino = (dd.get_path("geih_empalme" if sel["empalme"] else "geih") / "exportaciones"
+               / f"{nombre}{'_empalme' if sel['empalme'] else ''}.csv")
+    st.caption(f"Se escribe un CSV de {fmt_num(n_total)} filas en `{destino}`, un mes a la vez: no hace falta "
+               "tener todos los meses en memoria.")
+    if st.button("Exportar a CSV", key="exportar"):
+        barra, progreso = _barra("Exportando…")
+        filas = dd.geih.exportar(list(anios), destino, variables=elegidas, poblacion=poblacion,
+                                 filtros=sel["filtros"] or None, meses=sel["meses"], columns=list(columnas) or "core",
+                                 empalme=sel["empalme"], progress=progreso)
+        barra.empty()
+        st.success(f"Listo: {fmt_num(filas)} filas en `{destino}`.")
+        if destino.stat().st_size < 100e6:
+            st.download_button("⬇️ Descargar el CSV", destino.read_bytes(), destino.name, "text/csv")
+    codigo(f'''
+import dane_data as dd
+
+# Escribe los microdatos armonizados mes a mes, sin juntarlos en memoria
+dd.geih.exportar({list(anios)!r}, "{destino.name}", variables={elegidas!r}{args_py(poblacion=poblacion)}{args_comunes})
+''')
+    st.caption("💡 `fex` es el factor de expansión **mensual**: si junta varios meses, divida por el número "
+               "de meses (o use `dd.geih.serie_tabla`, que lo hace solo).")