dane-data 0.2.1__py3-none-any.whl

dane_data/app/paginas/geih_mercado.py

@@ -0,0 +1,152 @@
+import pandas as pd
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import (fmt_num, MAX_SERIES, args_py, barras, botones_descarga, codigo, fmt_grande, fmt_pct,
+                             fmt_pesos, grafico, linea, rutas_actuales, seleccion_geih, serie_geih)
+
+st.title("👥 Indicadores del mercado laboral")
+sel = seleccion_geih(clave="geih")
+
+
+def calcular(por, anual):
+    """Indicadores año por año, guardados en disco (con los filtros y meses de la barra lateral)."""
+    return serie_geih(tuple(sel["anios"]), por, anual, sel["empalme"], sel["filtros"],
+                      tuple(sel["meses"]) if sel["meses"] else None, sel["meses_disponibles"], rutas_actuales())
+
+
+total = calcular(None, True)
+if total.empty or not total["n_muestra"].sum():
+    st.warning("Ninguna persona cumple los filtros elegidos.")
+    st.stop()
+mensual = calcular(None, False)
+meses_ult = int((mensual["anio"] == total["anio"].iloc[-1]).sum())
+st.caption(f"**Datos:** {sel['descripcion']} · {fmt_num(total['n_muestra'].sum())} personas en la muestra")
+
+INDICADORES = {
+    "Tasa de desocupación (TD)": ("td", True),
+    "Tasa global de participación (TGP)": ("tgp", True),
+    "Tasa de ocupación (TO)": ("to", True),
+    "Tasa de informalidad": ("tasa_informalidad", True),
+    "Ingreso laboral mediano": ("ingreso_mediano", False),
+    "Ingreso laboral medio": ("ingreso_medio", False),
+    "Ocupados (personas)": ("ocupados", False),
+    "Desocupados (personas)": ("desocupados", False),
+    "Fuerza de trabajo (personas)": ("fuerza_trabajo", False),
+}
+DESAGREGAR = {
+    "Total nacional": None,
+    "Sexo": "sexo",
+    "Zona (urbano/rural)": "zona",
+    "Grupo de edad": "grupo_edad",
+    "Nivel educativo": "nivel_educativo",
+    "Departamento": "departamento",
+}
+
+# ---------------------------------------------------------------- KPIs
+ult = total.iloc[-1]
+prev = total.iloc[-2] if len(total) > 1 else None
+
+
+def delta(col, pct=True):
+    if prev is None or pd.isna(prev[col]):
+        return None
+    d = ult[col] - prev[col]
+    return f"{d:+.1f} p.p. vs {int(prev['anio'])}" if pct else f"{100 * d / prev[col]:+.1f} % vs {int(prev['anio'])}"
+
+
+st.markdown(f"##### Resumen {int(ult['anio'])}")
+k = st.columns(5)
+k[0].metric("Desocupación", fmt_pct(ult.td), delta("td"), delta_color="inverse",
+            help=dd.geih.GLOSARIO["TD"])
+k[1].metric("Participación (TGP)", fmt_pct(ult.tgp), delta("tgp"), help=dd.geih.GLOSARIO["TGP"])
+k[2].metric("Ocupación (TO)", fmt_pct(ult.to), delta("to"), help=dd.geih.GLOSARIO["TO"])
+k[3].metric("Informalidad", fmt_pct(ult.tasa_informalidad), delta("tasa_informalidad"), delta_color="inverse",
+            help=dd.geih.GLOSARIO["Informalidad"])
+k[4].metric("Ingreso laboral mediano", fmt_pesos(ult.ingreso_mediano), delta("ingreso_mediano", pct=False),
+            help=dd.geih.GLOSARIO["Ingreso laboral"] + " Pesos corrientes (sin ajustar por inflación).")
+if meses_ult < 12:
+    st.info(f"ℹ️ {int(ult['anio'])} tiene solo {meses_ult} mes(es) en la selección. La comparación con el año "
+            "anterior mezcla temporadas distintas (el desempleo es estacional); para comparar bien elija los "
+            "mismos meses en ambos años (desactive «Todos los meses»).")
+st.caption(f"Ocupados: **{fmt_grande(ult.ocupados)}** · Desocupados: **{fmt_grande(ult.desocupados)}** · "
+           f"Población en edad de trabajar: **{fmt_grande(ult.pet)}** (promedio mensual).")
+
+st.divider()
+
+# ---------------------------------------------------------------- Gráfico
+c1, c2, c3 = st.columns([2, 2, 1])
+nombre_ind = c1.selectbox("Indicador", list(INDICADORES))
+nombre_por = c2.selectbox("Desagregar por", list(DESAGREGAR))
+frecuencia = c3.radio("Frecuencia", ["Anual", "Mensual"], horizontal=True)
+col, es_pct = INDICADORES[nombre_ind]
+por = DESAGREGAR[nombre_por]
+anual = frecuencia == "Anual"
+
+res = calcular(por, anual)
+if por:
+    res = res[res[por].notna()]
+if por:  # grupos sin dato (p. ej. 0–14 años no está en la PET)
+    res = res[res.groupby(por, observed=True)[col].transform("count") > 0]
+if not anual:
+    res["periodo"] = pd.to_datetime(dict(year=res["anio"], month=res["mes"], day=1))
+x = "anio" if anual else "periodo"
+
+grupos = list(res[por].dropna().unique()) if por else []
+if por and len(grupos) > MAX_SERIES and res[x].nunique() > 1:
+    orden = res.groupby(por, observed=True)["ocupados"].sum().sort_values(ascending=False).index.tolist()
+    elegidos = st.multiselect(f"Hay {len(grupos)} grupos; elija hasta {MAX_SERIES} para comparar en el tiempo",
+                              orden, default=orden[:5], max_selections=MAX_SERIES)
+    res_graf = res[res[por].isin(elegidos)]
+else:
+    res_graf = res
+
+titulo = nombre_ind + (" (%)" if es_pct else "")
+if res_graf[x].nunique() > 1:
+    fig = linea(res_graf, x=x, y=col, color=por, titulo_y=titulo, pct=es_pct)
+else:
+    fig = barras(res_graf, x=por or x, y=col, titulo_y=titulo, pct=es_pct,
+                 horizontal=bool(por) and len(grupos) > 6)
+grafico(fig)
+
+pocos = res[res["n_muestra"] < 100]
+if len(pocos):
+    st.warning(f"⚠️ {len(pocos)} celda(s) tienen menos de 100 personas en la muestra: esas cifras son "
+               "poco confiables (mucho error de muestreo). Considere agrupar más meses o menos categorías.")
+
+# ---------------------------------------------------------------- Tabla
+with st.expander("📋 Tabla completa", expanded=False):
+    tabla = res.drop(columns=["periodo"], errors="ignore")
+    st.dataframe(
+        tabla, hide_index=True, width="stretch",
+        column_config={
+            "anio": st.column_config.NumberColumn("Año", format="%d"),
+            "mes": st.column_config.NumberColumn("Mes", format="%d"),
+            **{c: st.column_config.NumberColumn(c.upper(), format="%.1f %%") for c in ("tgp", "to", "td")},
+            "tasa_informalidad": st.column_config.NumberColumn("Informalidad", format="%.1f %%"),
+            **{c: st.column_config.NumberColumn(c.replace("_", " ").capitalize(), format="localized")
+               for c in ("pet", "fuerza_trabajo", "ocupados", "desocupados", "inactivos", "ingreso_medio",
+                         "ingreso_mediano", "n_muestra")},
+        },
+    )
+    botones_descarga(tabla, f"indicadores_geih_{'_'.join(map(str, sel['anios']))}", "ind")
+
+with st.expander("📖 ¿Qué significa cada indicador?"):
+    for k_, v in dd.geih.GLOSARIO.items():
+        st.markdown(f"**{k_}.** {v}")
+    st.markdown(
+        "**Promedio mensual.** La GEIH es mensual: al juntar varios meses, los niveles (personas) son el "
+        "promedio de los meses y las tasas se calculan sobre esos promedios, como hace el DANE.\n\n"
+        "**Muestra vs población.** `n_muestra` es cuántas personas se encuestaron; los niveles usan el "
+        "factor de expansión para representar a todo el país."
+    )
+
+argumentos = f'{f", por={por!r}" if por else ""}{", anual=False" if not anual else ""}'
+codigo(f'''
+import dane_data as dd
+
+# Igual a dd.geih.indicadores(...) sobre los microdatos filtrados, pero año por año y
+# guardado en caché: la segunda vez es instantáneo.
+ind = dd.geih.serie_indicadores({sel["anios"]!r}{argumentos}{args_py(empalme=sel["empalme"], filtros=sel["filtros"], meses=sel["meses"])})
+ind
+''')

dane_data/app/paginas/inicio.py

@@ -0,0 +1,79 @@
+import streamlit as st
+
+import dane_data as dd
+from dane_data.app._ui import disponibles_eam, disponibles_geih, rutas_actuales
+
+st.title("📊 DANE-data")
+st.markdown(
+    "#### Microdatos del DANE listos para analizar\n"
+    "Esta aplicación descarga, organiza y resume dos encuestas oficiales de Colombia publicadas por el DANE:"
+)
+
+c1, c2 = st.columns(2)
+with c1, st.container(border=True):
+    st.markdown(
+        "##### 👥 GEIH — Gran Encuesta Integrada de Hogares\n"
+        "Encuesta **mensual** a ~70.000 personas. Es la fuente oficial del **desempleo**, la "
+        "**informalidad** y los **ingresos laborales**. Cada fila es una persona; el *factor de "
+        "expansión* dice a cuántas personas del país representa.\n\n"
+        "**Úsela para:** brechas de género, desempleo juvenil, informalidad por región, "
+        "ingresos frente al salario mínimo…"
+    )
+with c2, st.container(border=True):
+    st.markdown(
+        "##### 🏭 EAM — Encuesta Anual Manufacturera\n"
+        "Censo **anual** de ~7.000 establecimientos industriales (1992–2024). Cada fila es una "
+        "planta: producción, valor agregado, empleo, salarios, activos y energía.\n\n"
+        "**Úsela para:** productividad por sector, participación laboral, concentración "
+        "regional, funciones de producción y costos…"
+    )
+
+st.subheader("¿Cómo empiezo?")
+st.markdown(
+    "1. **Datos:** si aún no los tiene, vaya a **⬇️ Descargar datos** (menú izquierdo). "
+    "Si ya los descargó, indique la carpeta abajo.\n"
+    "2. **Explore:** abra **👥 Indicadores laborales** o **🏭 Indicadores industriales**, elija años y filtros.\n"
+    "3. **Exporte:** cada tabla se descarga en CSV, Excel o Stata. Cada página muestra el "
+    "**código Python** equivalente para pasar a un notebook cuando esté listo."
+)
+
+# ---------------------------------------------------------------- Estado de datos
+st.subheader("Datos disponibles en este computador")
+rutas = rutas_actuales()
+g, e, ge = disponibles_geih(False, rutas), disponibles_eam(rutas), disponibles_geih(True, rutas)
+
+m1, m2, m3 = st.columns(3)
+m1.metric("GEIH (serie principal)", f"{g.anio.nunique()} años" if len(g) else "Sin datos",
+          f"{g.anio.min()}–{g.anio.max()} · {len(g)} meses" if len(g) else None, delta_color="off")
+m2.metric("GEIH (serie de empalme)", f"{ge.anio.nunique()} años" if len(ge) else "Sin datos",
+          f"{ge.anio.min()}–{ge.anio.max()}" if len(ge) else None, delta_color="off")
+m3.metric("EAM", f"{e.anio.nunique()} años" if len(e) else "Sin datos",
+          f"{e.anio.min()}–{e.anio.max()}" if len(e) else None, delta_color="off")
+
+incompletos = g[~g.completo] if len(g) else g
+if len(incompletos):
+    with st.expander(f"⚠️ {len(incompletos)} mes(es) de la GEIH están incompletos y se omitirán"):
+        st.dataframe(incompletos[["anio", "nombre_mes", "carpeta", "faltantes"]], hide_index=True)
+        st.caption("Vuelva a descargarlos en ⬇️ Descargar datos (borre antes la carpeta de ese mes).")
+
+# ---------------------------------------------------------------- Configuración
+with st.expander("⚙️ Carpetas de datos", expanded=not (len(g) or len(e))):
+    st.caption(
+        "Indique dónde están (o dónde quiere guardar) los datos. Para la GEIH, la carpeta que "
+        "contiene `datos_csv/`; para la EAM, la que contiene `datos/`. Se recuerda para la próxima vez."
+    )
+    with st.form("rutas"):
+        p_geih = st.text_input("GEIH serie principal", str(dd.get_path("geih")))
+        p_emp = st.text_input("GEIH serie de empalme", str(dd.get_path("geih_empalme")))
+        p_eam = st.text_input("EAM", str(dd.get_path("eam")))
+        if st.form_submit_button("Guardar", type="primary"):
+            dd.set_paths(geih=p_geih, geih_empalme=p_emp, eam=p_eam, save=True)
+            st.cache_data.clear()
+            st.cache_resource.clear()
+            st.rerun()
+
+st.divider()
+st.caption(
+    "Fuente: DANE — Archivo Nacional de Datos (ANDA), microdatos anonimizados de uso público. "
+    "Cite: *DANE, Gran Encuesta Integrada de Hogares (GEIH)* / *Encuesta Anual Manufacturera (EAM)*."
+)

dane_data/cli.py

@@ -0,0 +1,149 @@
+"""
+Línea de comandos de dane_data.
+
+    dane-data app                                   # abre la aplicación gráfica
+    dane-data estado                                # qué datos hay descargados
+    dane-data config --geih RUTA --eam RUTA         # dónde están/estarán los datos
+    dane-data descargar geih --anios 2024 2025
+    dane-data descargar geih --anios 2016 --empalme
+    dane-data descargar eam --anios 2022 2023 2024
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import socket
+import subprocess
+import sys
+import threading
+import time
+import urllib.request
+import webbrowser
+from pathlib import Path
+
+from . import config, eam, geih
+
+
+def _puerto_libre(preferido: int) -> int:
+    """El puerto pedido si está libre; si no, el siguiente libre."""
+    for puerto in range(preferido, preferido + 50):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(("127.0.0.1", puerto)) != 0:
+                return puerto
+    return preferido
+
+
+def _abrir_navegador_cuando_lista(url: str, proceso: subprocess.Popen, espera_max: float = 120) -> None:
+    """Espera a que Streamlit responda y abre el navegador (una sola vez)."""
+    salud = url.rstrip("/") + "/_stcore/health"
+    limite = time.time() + espera_max
+    while time.time() < limite and proceso.poll() is None:
+        try:
+            with urllib.request.urlopen(salud, timeout=1) as r:
+                if r.status == 200:
+                    webbrowser.open(url)
+                    return
+        except OSError:
+            pass
+        time.sleep(0.5)
+
+
+def _cmd_app(args) -> int:
+    app = Path(__file__).parent / "app" / "Inicio.py"
+    puerto = _puerto_libre(args.port)
+    url = f"http://localhost:{puerto}"
+    # headless: Streamlit no abre el navegador ni pide correo la primera vez; lo abrimos nosotros.
+    cmd = [sys.executable, "-m", "streamlit", "run", str(app), "--server.port", str(puerto),
+           "--server.address", args.address, "--server.headless", "true",
+           "--browser.gatherUsageStats", "false"]
+    print(f"\n  dane-data se está abriendo en {url}")
+    print("  Para cerrarla, cierre esta ventana o presione Ctrl+C.\n", flush=True)
+    proceso = subprocess.Popen(cmd, cwd=app.parent)  # cwd: para que lea app/.streamlit/config.toml
+    if not args.no_browser:
+        threading.Thread(target=_abrir_navegador_cuando_lista, args=(url, proceso), daemon=True).start()
+    try:
+        return proceso.wait()
+    except KeyboardInterrupt:
+        proceso.terminate()
+        try:
+            proceso.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            proceso.kill()
+        return 0
+
+
+def _cmd_estado(args) -> int:
+    for key, label in (("geih", "GEIH principal"), ("geih_empalme", "GEIH empalme"), ("eam", "EAM")):
+        print(f"{label:15s} {config.get_path(key)}")
+    for emp in (False, True):
+        av = geih.available(empalme=emp)
+        nombre = "GEIH empalme" if emp else "GEIH principal"
+        if av.empty:
+            print(f"\n{nombre}: sin datos")
+            continue
+        resumen = av.groupby("anio").agg(meses=("mes", "size"), incompletos=("completo", lambda s: (~s).sum()))
+        print(f"\n{nombre}:")
+        print(resumen.to_string())
+    av = eam.available()
+    print("\nEAM:", "sin datos" if av.empty else f"{len(av)} años ({av.anio.min()}–{av.anio.max()})")
+    return 0
+
+
+def _cmd_config(args) -> int:
+    config.set_paths(geih=args.geih, geih_empalme=args.empalme, eam=args.eam, save=True)
+    print(f"Guardado en {config.CONFIG_FILE}")
+    for k, v in config.show_paths().items():
+        print(f"  {k:13s} {v}")
+    return 0
+
+
+def _cmd_descargar(args) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    if args.encuesta == "geih":
+        geih.download(years=args.anios, modules=args.modulos, empalme=args.empalme,
+                      delete_zips=args.borrar_zips, limit_files=args.limite)
+    else:
+        eam.download(years=args.anios, include_tic=args.tic, delete_zips=args.borrar_zips)
+    return 0
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="dane-data", description="Microdatos DANE (GEIH y EAM) para economistas.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    a = sub.add_parser("app", help="Abrir la aplicación gráfica en el navegador")
+    a.add_argument("--port", type=int, default=8501, help="Puerto preferido (si está ocupado se usa el siguiente)")
+    a.add_argument("--no-browser", action="store_true", help="No abrir el navegador automáticamente")
+    a.add_argument("--address", default="localhost", help="Use 0.0.0.0 para compartir en la red local (aula)")
+    a.set_defaults(fn=_cmd_app)
+
+    e = sub.add_parser("estado", help="Mostrar rutas y datos disponibles")
+    e.set_defaults(fn=_cmd_estado)
+
+    c = sub.add_parser("config", help="Configurar carpetas de datos (se guarda para siempre)")
+    c.add_argument("--geih", help="Carpeta de la GEIH principal (la que contiene datos_csv/)")
+    c.add_argument("--empalme", help="Carpeta de la GEIH empalme (la que contiene datos_csv/)")
+    c.add_argument("--eam", help="Carpeta de la EAM (la que contiene datos/)")
+    c.set_defaults(fn=_cmd_config)
+
+    d = sub.add_parser("descargar", help="Descargar microdatos del DANE")
+    d.add_argument("encuesta", choices=["geih", "eam"])
+    d.add_argument("--anios", nargs="+", type=int, help="Años (por defecto todos)")
+    d.add_argument("--modulos", nargs="+", choices=list(geih.MODULE_PATTERNS), help="Solo GEIH")
+    d.add_argument("--empalme", action="store_true", help="GEIH: serie de empalme 2010–2020")
+    d.add_argument("--limite", type=int, help="GEIH: máximo de archivos mensuales por año (pruebas)")
+    d.add_argument("--tic", action="store_true", help="EAM: incluir módulo TIC 2008–2018")
+    d.add_argument("--borrar-zips", action="store_true", help="Borrar los ZIP tras extraer")
+    d.set_defaults(fn=_cmd_descargar)
+
+    args = p.parse_args(argv)
+    try:
+        return args.fn(args)
+    except KeyboardInterrupt:
+        print("\nInterrumpido.")
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dane_data/config.py

@@ -0,0 +1,80 @@
+"""
+Configuración de rutas de datos.
+
+Cada encuesta vive en su propia carpeta raíz, con la misma estructura que
+generan los descargadores originales:
+
+    GEIH  (serie principal) : <raiz>/datos_csv/<año>/<mes>/*.csv
+    GEIH  (serie empalme)   : <raiz>/datos_csv/<año>/<mes>/*.csv
+    EAM                     : <raiz>/datos/<año>/*.csv|*.txt
+
+Prioridad para resolver cada ruta:
+  1. ``set_paths(...)`` en la sesión actual.
+  2. Variables de entorno ``DANE_DATA_GEIH``, ``DANE_DATA_GEIH_EMPALME``, ``DANE_DATA_EAM``.
+  3. Archivo ``~/.config/dane_data/config.json`` (lo escribe ``save()`` y la app).
+  4. Valor por defecto bajo ``~/dane_data_datos/``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+CONFIG_FILE = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "dane_data" / "config.json"
+CACHE_DIR = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "dane_data"
+DEFAULT_HOME = Path.home() / "dane_data_datos"
+
+_KEYS = {
+    "geih": ("DANE_DATA_GEIH", DEFAULT_HOME / "geih"),
+    "geih_empalme": ("DANE_DATA_GEIH_EMPALME", DEFAULT_HOME / "geih" / "empalme"),
+    "eam": ("DANE_DATA_EAM", DEFAULT_HOME / "eam"),
+}
+_session: dict[str, Path] = {}
+
+
+def _read_file() -> dict:
+    try:
+        return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+
+
+def get_path(key: str) -> Path:
+    """Devuelve la carpeta raíz de ``key`` ('geih', 'geih_empalme' o 'eam')."""
+    if key not in _KEYS:
+        raise KeyError(f"Clave desconocida {key!r}. Opciones: {list(_KEYS)}")
+    if key in _session:
+        return _session[key]
+    env, default = _KEYS[key]
+    if os.environ.get(env):
+        return Path(os.environ[env]).expanduser()
+    stored = _read_file().get(key)
+    if stored:
+        return Path(stored).expanduser()
+    return default
+
+
+def set_paths(geih=None, geih_empalme=None, eam=None, save: bool = False) -> None:
+    """
+    Fija las carpetas raíz para esta sesión.
+
+    >>> import dane_data as dd
+    >>> dd.set_paths(geih="~/datos/GEIH/data", eam="~/datos/EAM/data", save=True)
+
+    Con ``save=True`` se guardan en ``~/.config/dane_data/config.json`` para
+    futuras sesiones (y para la app).
+    """
+    for key, val in (("geih", geih), ("geih_empalme", geih_empalme), ("eam", eam)):
+        if val is not None:
+            _session[key] = Path(val).expanduser()
+    if save:
+        data = _read_file()
+        data.update({k: str(v) for k, v in _session.items()})
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def show_paths() -> dict[str, str]:
+    """Rutas efectivas actuales (útil para depurar)."""
+    return {k: str(get_path(k)) for k in _KEYS}