#!/usr/bin/env python import requests import httpx import asyncio from tqdm import tqdm import jsonlines from datetime import datetime, timezone import pandas as pd from pathlib import Path from utils import async_httpx_retry from deepdiff import DeepDiff import json def listarTramites(pageSize=30): """ Lista todos los trámites disponibles. """ print("Listando trámites ...") tramites = [] page = 1 while True: try: url = f"https://www.gob.bo/ws/api/portal/tramites?pagina={page}&limite={pageSize}" response = requests.get(url) datos = response.json()["datos"] tramites.extend( [{k: e[k] for k in ["id", "nombre", "slug"]} for e in datos["filas"]] ) print(f"{len(tramites)} de {datos['total']}") if len(tramites) >= datos["total"]: break else: page += 1 except Exception as e: print(f"{e}") tramites = list({d["slug"]: d for d in tramites}.values()) return tramites @async_httpx_retry(max_retries=5, base_delay=0.5) async def getTramite(tramite_slug, client): """ Descarga datos de un trámite. """ url = f"https://www.gob.bo/ws/api/portal/tramites/{tramite_slug}" resp = await client.get(url) resp.raise_for_status() return resp.json() async def getTramites(tramitesListado, max_concurrent=10, max_tramites=None): """ Descarga asíncrona de datos de trámites en un listado. """ tramites = [] errores = [] sema = asyncio.Semaphore(max_concurrent) subset = tramitesListado if max_tramites is None else tramitesListado[:max_tramites] pbar = tqdm(total=len(tramitesListado), desc="Descargando trámites") async def fetch_one(tramite, client): async with sema: try: data = await getTramite(tramite["slug"], client) tramites.append(data["datos"]) except Exception as e: print(e) errores.append({**tramite, "error": str(e)}) pbar.update(1) async with httpx.AsyncClient(headers={"User-Agent": "Mozilla/5.0"}) as client: await asyncio.gather(*(fetch_one(t, client) for t in subset)) pbar.close() return tramites, errores def detectarModificaciones(df1, df2, timestamp): """ Detecta trámites que cambian entre dos corridas consecutivas df1 y df2. Construye y guarda una bitácora de estos trámites más una estampa de tiempo. """ def listarCamposCompuestos(): """ Listar campos cuyos valores esperamos que sean arrays u objetos. """ with open("datapackage.json", "r") as f: datapackage = json.load(f) return [ field["name"] for field in datapackage["resources"][0]["schema"]["fields"] if field["type"] in ["array", "object"] ] FILENAME = Path("modificaciones.csv") # Alinear trámites _df1, _df2 = df1.set_index("id").copy(), df2.set_index("id").copy() nombres = _df1.nombre.to_dict() entidades = _df1["entidad"].apply(lambda _: _["nombre"]).to_dict() cols = [c for c in _df1.columns if c in _df2.columns and c != "id"] idx = _df1.index.intersection(_df2.index) _df1, _df2 = _df1.loc[idx, cols], _df2.loc[idx, cols] # Comparar cada columna e identificar cambios cambios = [] camposCompuestos = listarCamposCompuestos() for col in cols: old, new = _df1[col], _df2[col] modified = old.ne(new) & ~(old.isna() & new.isna()) # Si existen modificaciones if modified.any(): # Si los valores son arrays u objetos if col in camposCompuestos: for id_tramite, v1, v2 in zip( old.index[modified].values, old[modified].values, new[modified].values, ): # Detectar cambios detallados y agregar cada uno en una fila diff = DeepDiff(v1, v2) for key in diff["values_changed"].keys(): campo = f"{col}{key.replace('root', '')}" viejo, nuevo = [ diff["values_changed"][key][v] for v in ["old_value", "new_value"] ] cambios.append( { "timestamp": timestamp, "id": id_tramite, "entidad": entidades[id_tramite], "nombre": nombres[id_tramite], "campo": campo, "viejo": viejo, "nuevo": nuevo, } ) else: # Si los valores son simples for id_tramite, viejo, nuevo in zip( old.index[modified].values, old[modified].values, new[modified].values, ): cambios.append( { "timestamp": timestamp, "id": id_tramite, "entidad": entidades[id_tramite], "nombre": nombres[id_tramite], "campo": col, "viejo": viejo, "nuevo": nuevo, } ) # Guardar cambios print(f"{len(cambios)} modificaciones") if len(cambios) > 0: modificaciones = pd.DataFrame(cambios) if FILENAME.exists(): modificaciones = pd.concat([pd.read_csv(FILENAME), modificaciones]) modificaciones.sort_values(["timestamp", "id", "campo"]).to_csv( FILENAME, index=False ) def detectarAdiciones(df1, df2, timestamp): """ Detecta trámites que aparecen o desaparecen entre dos corridas consecutivas df1 y df2. Construye y guarda una bitácora de estos trámites más una estampa de tiempo. """ FILENAME = Path("adiciones.csv") # El formato de la bitácora def formatear(df, evento, timestamp): n = df[["id", "entidad", "nombre"]].copy() n["entidad"] = n["entidad"].str["nombre"] n.columns = ["id", "entidad", "nombre"] n.insert(0, "tipo", evento) n.insert(0, "timestamp", timestamp) return n # Detectar trámites que aparecen o desaparecen eventos = pd.concat( [ formatear(df2[~df2["id"].isin(df1["id"])], "aparece", timestamp), formatear(df1[~df1["id"].isin(df2["id"])], "desaparece", timestamp), ] ) # Guardar registros print(f"{eventos.shape[0]} trámites que aparecen o desaparecen") if eventos.shape[0] > 0: if FILENAME.exists(): eventos = pd.concat([pd.read_csv(FILENAME), eventos]) eventos.sort_values(["timestamp", "id", "tipo"]).to_csv(FILENAME, index=False) async def main(): """ Lista todos los trámites disponibles y descarga datos para cada uno en una serie de reintentos. Luego guarda todos estos datos más posibles errores junto a bitácoras de trámites que aparecen, desaparecen o son modificados entre corridas consecutivas. """ FILENAME = Path("tramites.jsonl") # Listar tramites pendientes = listarTramites() print(f"{len(pendientes)} tramites listados") # Estampa de tiempo timestamp = datetime.now(timezone.utc).isoformat(timespec="minutes") tramites, errores = await getTramites(pendientes) print(f"{len(tramites)} registros, {len(errores)} errores") # Consolidar con datos recogidos previamente if FILENAME.exists(): tramites_df = pd.DataFrame(tramites) with jsonlines.open(FILENAME, "r") as f: tramites_previos = pd.DataFrame([line for line in f]) detectarAdiciones(tramites_previos, tramites_df, timestamp) detectarModificaciones(tramites_previos, tramites_df, timestamp) # Guardar trámites y errores tramites_sorted = sorted(tramites, key=lambda d: d["id"]) for data, filename in zip([tramites_sorted, errores], ["tramites", "errores"]): if data: with jsonlines.open(f"{filename}.jsonl", "w") as f: for entry in data: f.write(entry) print(f"Datos guardados: {len(tramites_sorted)} trámites | {len(errores)} errores.") if __name__ == "__main__": asyncio.run(main())