19  Pipelines de ingesta y cargas incrementales

big-data
ingenieria-datos
ingesta
pyspark
hdfs
Autor/a

Wilder Ramírez Delgado

Fecha de publicación

27 de octubre de 2026

El problema que vas a resolver

Hasta aquí, BITLogística (empresa ficticia; los datos son sintéticos y no corresponden a BIT ni a ningún cliente) trabajó con seis archivos mensuales que llegaron juntos. Desde julio el sistema de admisión cambia: deja un archivo por día en la zona de llegada, cada noche. Y la operación real trae sus problemas. Algunos envíos se reportan uno o dos días tarde, en el archivo de otro día. A veces un archivo llega cortado y al día siguiente se envía corregido. Y nadie garantiza que el proceso de carga no se ejecute dos veces la misma noche.

Volver a procesar todo cada día funcionaría con diez archivos, pero no con tres años de archivos. Este capítulo construye un pipeline de ingesta incremental: un proceso que en cada ejecución carga solo lo nuevo o lo que cambió, se puede repetir sin duplicar nada, reprocesa las correcciones y deja constancia de lo que hizo.

Ficha En este capítulo
Pregunta ¿Cómo se cargan cada día solo los datos nuevos sin duplicar ni perder ninguno?
Datos Diez archivos diarios de envíos de BITLogística, del 1 al 10 de julio de 2026, más una versión corregida del día 4
Tiempo estimado de lectura 55 minutos, más la práctica
Nivel Intermedio
Conocimientos previos recomendados Bronce, plata, cuarentena y reglas de validación del taller de PySpark; particiones por carpeta en Almacenamiento analítico; funciones de ventana en Spark SQL y DataFrames
Tecnologías mencionadas Spark 3.5.3, PySpark, HDFS, Parquet; como continuación: Apache Iceberg y Apache Airflow

Objetivos de aprendizaje

Al terminar este capítulo podrás:

  1. Distinguir una carga completa de una carga incremental y explicar cuándo conviene cada una.
  2. Diseñar una carga idempotente, que al repetirse deja los datos igual.
  3. Detectar archivos nuevos o cambiados con un registro de cargas y la huella de su contenido.
  4. Explicar por qué una marca de agua por fecha no detecta un archivo corregido.
  5. Usar la sobrescritura dinámica de particiones para reemplazar solo los lotes y fechas que cambiaron.
  6. Incorporar datos tardíos sin perder ni duplicar envíos.
  7. Comprobar que la carga incremental produce lo mismo que una carga completa.
TipLo que necesitas recordar
Concepto En una línea Dónde se explica
Bronce, plata y cuarentena Datos tal como llegaron; limpios y tipados; rechazados con su motivo. Taller de PySpark, modelo de capas
Reglas como datos Cada regla de validación es un nombre y una condición; la fila guarda los nombres que incumple. Taller de PySpark, etapa 4
Tabla particionada Sus archivos se organizan en carpetas columna=valor. Almacenamiento analítico, sección 8
ROW_NUMBER sobre una ventana Numera las filas de cada grupo en un orden. Spark SQL y DataFrames, sección 9
Unión anti Filas de una tabla sin pareja en otra. Spark SQL y DataFrames, sección 8

Antes de empezar

El capítulo es un notebook que se ejecuta en el Jupyter de spark-client, con el kernel Python del clúster. En el apéndice «Operar el clúster» están el arranque y la descarga: el archivo se llama taller_ingesta.ipynb dentro de talleres-notebooks.zip. Necesita generar_envios.py, el generador del taller de PySpark, en la misma carpeta del notebook (~/hdfs-docker-lab/notebooks); viene en el mismo zip.

El notebook escribe dos cosas en esa carpeta: pipeline_envios.py, el módulo con las funciones del pipeline, y entregas_julio/, con los archivos diarios. En HDFS trabaja en /bitlogistica/ingesta, que ocupa menos de 1 MB y se conserva para el capítulo de calidad. Si ejecutas el notebook otra vez, la primera celda del pipeline borra esa carpeta para empezar desde cero. Las capas de enero a junio no se tocan.

1. La sesión

La sesión se abre con una opción que cambia lo que hace mode("overwrite") sobre una tabla particionada.

NotaSobrescritura dinámica de particiones

Por defecto, escribir con mode("overwrite") y partitionBy borra toda la tabla y escribe solo lo nuevo. Con spark.sql.sources.partitionOverwriteMode en dynamic, Spark reemplaza únicamente las particiones que aparecen en los datos que escribe y deja las demás como estaban. Escribir el lote del 4 de julio reemplaza la carpeta lote=2026-07-04 y no toca las de los otros días.

import os
import platform
import random
from collections import defaultdict

import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
from pyspark.sql import SparkSession
from pyspark.sql import functions as F

BASE = "hdfs://namenode:9000/bitlogistica"
INGESTA = BASE + "/ingesta"

spark = (
    SparkSession.builder
    .appName("ingesta-incremental")
    .config("spark.ui.showConsoleProgress", "false")
    .config("spark.sql.sources.partitionOverwriteMode", "dynamic")
    .getOrCreate()
)
spark.sparkContext.setLogLevel("ERROR")
sc = spark.sparkContext
assert sc.master == "yarn", "La sesión no está en YARN: revisa el kernel (Python del clúster)"

print("Python", platform.python_version(), "| Spark", spark.version)
print("master:", sc.master, "| aplicación:", sc.applicationId)
print("Sobrescritura de particiones:", spark.conf.get("spark.sql.sources.partitionOverwriteMode"))
print("Carpeta de trabajo del notebook:", os.getcwd())
Python 3.11.10 | Spark 3.5.3
master: yarn | aplicación: application_1793129130315_0008
Sobrescritura de particiones: dynamic
Carpeta de trabajo del notebook: /opt/spark/work-dir

La sesión quedó en YARN, con la sobrescritura de particiones en dynamic. La última línea muestra la carpeta de trabajo del notebook: ahí se escribe el módulo del pipeline y desde ahí se importa el generador de datos.

2. El pipeline como módulo

Antes del código, tres conceptos que definen lo que el pipeline debe cumplir.

NotaCarga completa, carga incremental y lote

En una carga completa se vuelve a procesar todo el histórico en cada ejecución y se reemplaza el resultado. En una carga incremental se procesa solo lo que llegó o cambió desde la ejecución anterior. Un lote es la unidad de llegada; aquí, el archivo de un día, identificado por la fecha de su nombre: envios_2026-07-04.csv es el lote 2026-07-04.

NotaIdempotencia

Una operación es idempotente si ejecutarla una vez o varias deja el mismo resultado. Una carga idempotente se puede repetir después de un fallo, o por error, sin duplicar filas. Es la propiedad más importante de un pipeline que corre solo cada noche.

NotaHuella de un archivo y registro de cargas

La huella (hash) de un archivo es un código corto calculado a partir de todo su contenido, como MD5. Si cambia un solo byte, cambia la huella. El registro de cargas es una tabla del pipeline con una fila por archivo procesado: nombre, huella, filas leídas y rechazadas, y la ejecución que lo cargó. Un archivo está pendiente si su nombre y su huella no aparecen juntos en el registro.

Cuatro cajas de izquierda a derecha unidas por flechas: zona de llegada con un archivo por día; la pregunta ya se cargó, resaltada, que compara archivo y huella MD5 contra el registro de cargas; bronce particionado por lote con sobrescritura dinámica; plata particionada por fecha, donde se recalculan las fechas afectadas. Debajo, el registro de cargas alimenta la pregunta, bronce envía filas a la cuarentena particionada por lote, y una caja que dice una fila por guía, la del lote más reciente, apunta a la plata. Arriba, el texto: si no hay pendientes, la ejecución no cambia nada.

Recorrido de una ejecución del pipeline incremental.

El pipeline sigue el recorrido de la figura y lo cumple con cuatro decisiones:

  • Qué cargar: los archivos de la zona de llegada cuyo nombre y huella no están en el registro de cargas.
  • Bronce por lote: cada lote se escribe en su partición lote=… con sobrescritura dinámica. Si un lote se vuelve a cargar, por ejemplo con una versión corregida, reemplaza al anterior en lugar de sumarse.
  • Plata por fecha de admisión: un lote puede traer envíos de días anteriores, así que la plata no se escribe por lote sino por fecha. En cada ejecución se recalculan completas las fechas que tocan los lotes cargados, con las filas de todos los lotes de bronce, y se deja una fila por guía.
  • Registro al final: solo cuando bronce, cuarentena y plata quedaron escritas, se agregan las filas del registro de cargas. Si la ejecución falla antes, los archivos siguen pendientes y la próxima los vuelve a intentar.

Las funciones viven en un módulo, un archivo .py que otros notebooks pueden importar. Los capítulos de calidad y de orquestación lo reutilizan. La celda lo escribe con %%writefile, una instrucción de Jupyter que guarda el contenido de la celda en un archivo en lugar de ejecutarlo. Las reglas de validación, el catálogo de ciudades y las correcciones de escritura son las mismas del taller de PySpark:

  • archivos_en_llegada lee la zona de llegada con el formato binaryFile de Spark, que devuelve cada archivo con su contenido, y calcula su huella con F.md5. pendientes le resta, con una unión anti, lo que ya está en el registro.
  • leer_lote, normalizar y validar son la ingesta a bronce, la limpieza y las reglas del taller, ahora como funciones.
  • quitar_duplicados usa ROW_NUMBER para quedarse con una fila por guía, la del lote más reciente.
  • a_plata calcula las columnas de negocio del taller y conserva la procedencia: archivo_origen, lote e id_ejecucion.
  • cargar_pendientes hace una ejecución completa del pipeline y devuelve un resumen.
%%writefile pipeline_envios.py
"""Pipeline de ingesta incremental de BITLogística (empresa ficticia, datos sintéticos).

Lo escribe el capítulo «Pipelines de ingesta y cargas incrementales» y lo reutilizan
los capítulos de calidad y de orquestación.
"""
from datetime import datetime

from pyspark.sql import Window
from pyspark.sql import functions as F

COLUMNAS = ["guia", "fecha_admision", "hora_admision", "origen", "destino", "distancia_km",
            "servicio", "canal", "operador", "peso_kg", "valor_declarado", "intentos_entrega",
            "estado", "fecha_hora_entrega"]

CIUDADES = ["Bogotá", "Medellín", "Cali", "Barranquilla", "Cartagena", "Bucaramanga",
            "Pereira", "Manizales", "Ibagué", "Villavicencio", "Santa Marta", "Neiva",
            "Cúcuta", "Montería", "Pasto"]
REMOTAS = ["Cúcuta", "Montería", "Pasto"]
ALIAS_CIUDAD = {"bogota d.c.": "Bogotá", "santiago de cali": "Cali", "b/quilla": "Barranquilla"}
ALIAS_SERVICIO = {"express": "Express", "expres": "Express",
                  "estandar": "Estándar", "economico": "Económico"}
PROMESA_HORAS = {"Express": 24, "Estándar": 72, "Económico": 120}
DIAS = ["domingo", "lunes", "martes", "miércoles", "jueves", "viernes", "sábado"]

REGLAS = [
    ("guia_vacia", "guia IS NULL"),
    ("peso_fuera_de_rango", "peso_kg IS NULL OR peso_kg < 0.01 OR peso_kg > 150"),
    ("distancia_no_positiva", "distancia_km IS NULL OR distancia_km <= 0"),
    ("ciudad_desconocida", "origen IS NULL OR destino IS NULL"),
    ("servicio_desconocido", "servicio IS NULL"),
    ("admision_invalida", "admision IS NULL"),
    ("entregado_sin_fecha", "estado = 'entregado' AND entrega IS NULL"),
    ("entrega_antes_de_admision", "entrega < admision"),
]


def llave(columna):
    """Texto comparable: sin espacios a los lados, en minúsculas y sin tildes."""
    return F.translate(F.lower(F.trim(columna)), "áéíóú", "aeiou")


def _mapa(pares):
    return F.create_map(*[F.lit(x) for par in pares.items() for x in par])


MAPA_CIUDAD = {**{c.lower().translate(str.maketrans("áéíóú", "aeiou")): c for c in CIUDADES}, **ALIAS_CIUDAD}


# ---------------------------------------------------------------- archivos
def sistema(spark, ruta):
    camino = spark.sparkContext._jvm.org.apache.hadoop.fs.Path(ruta)
    return camino, camino.getFileSystem(spark.sparkContext._jsc.hadoopConfiguration())


def existe(spark, ruta):
    camino, fs = sistema(spark, ruta)
    return fs.exists(camino)


def archivos_en_llegada(spark, llegada):
    """Una fila por CSV en la zona de llegada, con su lote y la huella MD5 de su contenido."""
    return (
        spark.read.format("binaryFile").option("pathGlobFilter", "envios_*.csv").load(llegada)
        .select(
            F.element_at(F.split("path", "/"), -1).alias("archivo"),
            F.regexp_extract("path", r"envios_(\d{4}-\d{2}-\d{2})", 1).alias("lote"),
            F.col("length").alias("bytes"),
            F.md5("content").alias("huella"),
            "path",
        )
    )


def pendientes(spark, rutas):
    """Archivos que no están en el registro de cargas con esa misma huella."""
    llegados = archivos_en_llegada(spark, rutas["llegada"])
    if not existe(spark, rutas["control"]):
        return llegados
    cargados = spark.read.parquet(rutas["control"]).select("archivo", "huella")
    return llegados.join(cargados, ["archivo", "huella"], "left_anti")


# ---------------------------------------------------------------- transformaciones
def leer_lote(spark, ruta, archivo, lote, id_ejecucion):
    """Bronce: el CSV tal como llegó, todo como texto, con su procedencia."""
    return (
        spark.read.option("header", True).csv(ruta)
        .select(*[F.col(c).cast("string") for c in COLUMNAS])
        .withColumn("archivo_origen", F.lit(archivo))
        .withColumn("id_ejecucion", F.lit(id_ejecucion))
        .withColumn("fecha_carga", F.current_timestamp())
        .withColumn("lote", F.to_date(F.lit(lote)))
    )


def normalizar(bronce):
    """Corrige variantes de escritura y convierte los tipos. Lo que no se reconoce queda nulo."""
    ciudades, servicios = _mapa(MAPA_CIUDAD), _mapa(ALIAS_SERVICIO)
    return (
        bronce
        .withColumn("guia", F.trim("guia"))
        .withColumn("origen", ciudades[llave(F.col("origen"))])
        .withColumn("destino", ciudades[llave(F.col("destino"))])
        .withColumn("servicio", servicios[llave(F.col("servicio"))])
        .withColumn("admision", F.to_timestamp(F.concat_ws(" ", "fecha_admision", "hora_admision"),
                                               "yyyy-MM-dd HH:mm"))
        .withColumn("entrega", F.to_timestamp("fecha_hora_entrega", "yyyy-MM-dd HH:mm"))
        .withColumn("peso_kg", F.col("peso_kg").cast("double"))
        .withColumn("distancia_km", F.col("distancia_km").cast("int"))
        .withColumn("valor_declarado", F.col("valor_declarado").cast("long"))
        .withColumn("intentos_entrega", F.col("intentos_entrega").cast("int"))
        .withColumn("operador", F.coalesce(F.col("operador"), F.lit("Sin operador")))
    )


def validar(normalizada, reglas=REGLAS):
    """Agrega la columna motivos con el nombre de cada regla que la fila incumple."""
    marcas = [F.when(F.expr(condicion), F.lit(nombre)) for nombre, condicion in reglas]
    return normalizada.withColumn("motivos", F.array_compact(F.array(*marcas)))


def quitar_duplicados(validos):
    """Una fila por guía: la del lote más reciente y, dentro de él, la del archivo más reciente."""
    orden = Window.partitionBy("guia").orderBy(F.desc("lote"), F.desc("archivo_origen"))
    return validos.withColumn("n", F.row_number().over(orden)).filter("n = 1").drop("n")


def a_plata(validos):
    """Columnas de negocio, iguales a las de la plata del taller de PySpark, más la procedencia."""
    promesa = _mapa(PROMESA_HORAS)
    return (
        validos
        .select("guia", "admision", "entrega", "origen", "destino", "distancia_km", "servicio",
                "canal", "operador", "peso_kg", "valor_declarado", "intentos_entrega", "estado",
                "archivo_origen", "lote", "id_ejecucion")
        .withColumn("promesa_horas", promesa[F.col("servicio")])
        .withColumn("horas_transito",
                    F.round((F.unix_timestamp("entrega") - F.unix_timestamp("admision")) / 3600, 1))
        .withColumn("a_tiempo", F.when(F.col("estado") == "entregado",
                                       F.col("horas_transito") <= F.col("promesa_horas")))
        .withColumn("ruta", F.concat_ws(" - ", "origen", "destino"))
        .withColumn("dia_semana", F.element_at(F.array(*[F.lit(d) for d in DIAS]), F.dayofweek("admision")))
        .withColumn("fin_de_semana", F.dayofweek("admision").isin(1, 6, 7))
        .withColumn("destino_remoto", F.col("destino").isin(*REMOTAS))
        .withColumn("fecha", F.to_date("admision"))
    )


# ---------------------------------------------------------------- una ejecución
def cargar_pendientes(spark, rutas, id_ejecucion):
    """Carga incremental e idempotente de los archivos nuevos o cambiados de la zona de llegada."""
    inicio = datetime.now()
    nuevos = pendientes(spark, rutas).orderBy("lote", "archivo").collect()
    if not nuevos:
        return {"id_ejecucion": id_ejecucion, "archivos": 0, "lotes": [], "fechas_recalculadas": 0}

    # Si llegaron dos versiones del mismo lote, gana la última por nombre (…_v2 después de …)
    por_lote = {}
    for archivo in nuevos:
        por_lote[archivo["lote"]] = archivo
    lotes = sorted(por_lote)

    # Fechas que tenían estos lotes antes de reemplazarlos: también hay que recalcularlas
    fechas = set()
    if existe(spark, rutas["bronce"]):
        anteriores = spark.read.parquet(rutas["bronce"]).filter(F.col("lote").isin(lotes))
        fechas |= {f[0] for f in anteriores.select("fecha_admision").distinct().collect()}

    # 1. Bronce: cada lote reemplaza su propia partición (sobrescritura dinámica)
    tablas = [leer_lote(spark, a["path"], a["archivo"], a["lote"], id_ejecucion) for a in por_lote.values()]
    bronce_nuevo = tablas[0]
    for tabla in tablas[1:]:
        bronce_nuevo = bronce_nuevo.unionByName(tabla)
    bronce_nuevo.write.mode("overwrite").partitionBy("lote").parquet(rutas["bronce"])
    bronce = spark.read.parquet(rutas["bronce"])
    nuevo = bronce.filter(F.col("lote").isin(lotes))
    fechas |= {f[0] for f in nuevo.select("fecha_admision").distinct().collect()}
    fechas = sorted(f for f in fechas if f)

    # 2. Cuarentena de los lotes nuevos
    validada_nueva = validar(normalizar(nuevo))
    (validada_nueva.filter(F.size("motivos") > 0)
     .write.mode("overwrite").partitionBy("lote").parquet(rutas["cuarentena"]))

    # 3. Plata: se recalculan completas las fechas afectadas, con filas de todos los lotes
    afectadas = validar(normalizar(bronce.filter(F.col("fecha_admision").isin(fechas))))
    plata = a_plata(quitar_duplicados(afectadas.filter(F.size("motivos") == 0)))
    plata.write.mode("overwrite").partitionBy("fecha").parquet(rutas["plata"])

    # 4. Registro de cargas: una fila por archivo procesado
    resumen = (
        validada_nueva.groupBy("archivo_origen", "lote")
        .agg(F.count("*").alias("filas_leidas"),
             F.sum(F.when(F.size("motivos") > 0, 1).otherwise(0)).alias("filas_cuarentena"))
    )
    huellas = spark.createDataFrame([(a["archivo"], a["huella"], a["bytes"]) for a in nuevos],
                                    "archivo string, huella string, bytes long")
    registro = (
        huellas.join(resumen.withColumnRenamed("archivo_origen", "archivo"), "archivo", "left")
        .withColumn("id_ejecucion", F.lit(id_ejecucion))
        .withColumn("inicio", F.lit(inicio))
        .withColumn("fin", F.current_timestamp())
        .na.fill(0, ["filas_leidas", "filas_cuarentena"])
    )
    registro.write.mode("append").parquet(rutas["control"])
    return {"id_ejecucion": id_ejecucion, "archivos": len(nuevos), "lotes": lotes,
            "fechas_recalculadas": len(fechas)}
Overwriting pipeline_envios.py

Writing pipeline_envios.py (u Overwriting, si el archivo ya existía de una ejecución anterior) confirma que el módulo quedó en la carpeta del notebook. La celda siguiente lo importa, define las rutas de cada zona y borra /bitlogistica/ingesta si quedó de una ejecución anterior.

import importlib

import pipeline_envios as pe

importlib.reload(pe)
RUTAS = {
    "llegada": INGESTA + "/llegada",
    "bronce": INGESTA + "/bronce",
    "cuarentena": INGESTA + "/cuarentena",
    "plata": INGESTA + "/plata",
    "control": INGESTA + "/control/cargas",
}
camino, fs = pe.sistema(spark, INGESTA)
print("Zona de ingesta de una ejecución anterior borrada:", fs.delete(camino, True))
for zona, ruta in RUTAS.items():
    print(f"{zona:10s} {ruta}")
print("Reglas de validación:", [nombre for nombre, _ in pe.REGLAS])
Zona de ingesta de una ejecución anterior borrada: True
llegada    hdfs://namenode:9000/bitlogistica/ingesta/llegada
bronce     hdfs://namenode:9000/bitlogistica/ingesta/bronce
cuarentena hdfs://namenode:9000/bitlogistica/ingesta/cuarentena
plata      hdfs://namenode:9000/bitlogistica/ingesta/plata
control    hdfs://namenode:9000/bitlogistica/ingesta/control/cargas
Reglas de validación: ['guia_vacia', 'peso_fuera_de_rango', 'distancia_no_positiva', 'ciudad_desconocida', 'servicio_desconocido', 'admision_invalida', 'entregado_sin_fecha', 'entrega_antes_de_admision']

La primera línea dice True si había una zona de ingesta de una ejecución anterior y la borró, y False si es la primera vez. Las cinco zonas viven bajo /bitlogistica/ingesta. En producción, julio se agregaría a la misma plata de enero a junio; aquí va en su propia carpeta para no alterar las capas que usan los capítulos anteriores. Las ocho reglas son las del taller de PySpark.

3. Los archivos de julio

La celda usa las funciones del generador del taller de PySpark para crear los envíos del 1 al 10 de julio, con sus impurezas (nulos, valores imposibles, variantes de escritura y duplicados). Después los reparte en archivos diarios con dos problemas de la operación real:

  • El 4 % de los envíos se reporta uno o dos días tarde: queda en el archivo de un día posterior al de su admisión.
  • El archivo del 4 de julio llega primero cortado, con el 60 % de sus filas (envios_2026-07-04.csv), y después completo (envios_2026-07-04_v2.csv).
import csv
import shutil

import generar_envios as gen

rng = random.Random(707)
julio = [gen.generar_envio(rng, 7, n) for n in range(1, 6001)]
julio = [f for f in julio if int(f["fecha_admision"][8:10]) <= 10]
julio = gen.ensuciar(rng, julio, defaultdict(int))

lotes = defaultdict(list)
tardias = 0
for fila in julio:
    dia = int(fila["fecha_admision"][8:10])
    r = rng.random()
    retraso = 1 if r < 0.03 else 2 if r < 0.04 else 0   # 4 % se reporta uno o dos días después
    lote = min(dia + retraso, 10)
    tardias += lote != dia
    lotes[lote].append(fila)

CARPETA = os.path.abspath("entregas_julio")
shutil.rmtree(CARPETA, ignore_errors=True)      # empezar con la carpeta vacía en cada ejecución
os.makedirs(CARPETA)


def escribir(nombre, filas):
    ruta = os.path.join(CARPETA, nombre)
    with open(ruta, "w", newline="", encoding="utf-8") as f:
        escritor = csv.DictWriter(f, fieldnames=gen.COLUMNAS)
        escritor.writeheader()
        escritor.writerows(filas)
    return nombre


for dia, filas in sorted(lotes.items()):
    escribir(f"envios_2026-07-{dia:02d}.csv", filas)
    if dia == 4:   # el 4 de julio llega primero cortado, con el 60 % de las filas
        escribir("envios_2026-07-04.csv", filas[: int(len(filas) * 0.6)])
        escribir("envios_2026-07-04_v2.csv", filas)

print(f"Envíos generados del 1 al 10 de julio: {len(julio)} (con duplicados) | reportados tarde: {tardias}")
for nombre in sorted(os.listdir(CARPETA)):
    with open(os.path.join(CARPETA, nombre), encoding="utf-8") as f:
        print(f"  {nombre:28s} {sum(1 for _ in f) - 1:4d} filas")
Envíos generados del 1 al 10 de julio: 1937 (con duplicados) | reportados tarde: 81
  envios_2026-07-01.csv         180 filas
  envios_2026-07-02.csv         171 filas
  envios_2026-07-03.csv         206 filas
  envios_2026-07-04.csv         120 filas
  envios_2026-07-04_v2.csv      200 filas
  envios_2026-07-05.csv         192 filas
  envios_2026-07-06.csv         195 filas
  envios_2026-07-07.csv         194 filas
  envios_2026-07-08.csv         196 filas
  envios_2026-07-09.csv         185 filas
  envios_2026-07-10.csv         218 filas

Se generaron 1 937 envíos, contando los duplicados, y 81 quedaron en el archivo de un día posterior. Hay once archivos: uno por día con entre 171 y 218 filas, y los dos del día 4, el cortado con 120 filas y el completo con 200.

La función llegan simula al sistema de admisión: copia archivos de la carpeta local a la zona de llegada en HDFS. Primero llegan los tres primeros días.

def llegan(*nombres):
    """Simula que el sistema de admisión deja archivos en la zona de llegada de HDFS."""
    camino, fs = pe.sistema(spark, RUTAS["llegada"])
    fs.mkdirs(camino)
    for nombre in nombres:
        origen = spark._jvm.org.apache.hadoop.fs.Path("file://" + os.path.join(CARPETA, nombre))
        fs.copyFromLocalFile(False, True, origen, camino)
    return sorted(e.getPath().getName() for e in fs.listStatus(camino))


def estado_plata():
    """Filas de la plata por fecha de admisión."""
    if not pe.existe(spark, RUTAS["plata"]):
        return pd.Series(dtype=int)
    filas = spark.read.parquet(RUTAS["plata"]).groupBy("fecha").count().orderBy("fecha").collect()
    return pd.Series({str(f["fecha"])[5:]: f["count"] for f in filas})


print("Zona de llegada:", llegan("envios_2026-07-01.csv", "envios_2026-07-02.csv", "envios_2026-07-03.csv"))
print()
pe.archivos_en_llegada(spark, RUTAS["llegada"]).drop("path").orderBy("archivo").show(truncate=False)
Zona de llegada: ['envios_2026-07-01.csv', 'envios_2026-07-02.csv', 'envios_2026-07-03.csv']

+---------------------+----------+-----+--------------------------------+
|archivo              |lote      |bytes|huella                          |
+---------------------+----------+-----+--------------------------------+
|envios_2026-07-01.csv|2026-07-01|21253|d6538bcd7ee1627961db564e55fd764d|
|envios_2026-07-02.csv|2026-07-02|20321|dfce96d9d7e2787fdb1bb7a330393539|
|envios_2026-07-03.csv|2026-07-03|24489|5bcca7ae91f3ca3d092d1e61215ee825|
+---------------------+----------+-----+--------------------------------+

La zona de llegada tiene los tres archivos. Para cada uno, archivos_en_llegada sacó el lote del nombre, el tamaño en bytes y la huella MD5 de su contenido; con eso el pipeline decide qué cargar.

4. Primera ejecución

Cada ejecución recibe un identificador. Aquí es la fecha y hora en que habría corrido, la noche del 3 de julio.

resultado = pe.cargar_pendientes(spark, RUTAS, id_ejecucion="2026-07-03T23:00")
print(resultado)
print("Plata por fecha:", estado_plata().to_dict())
{'id_ejecucion': '2026-07-03T23:00', 'archivos': 3, 'lotes': ['2026-07-01', '2026-07-02', '2026-07-03'], 'fechas_recalculadas': 3}
Plata por fecha: {'07-01': 177, '07-02': 156, '07-03': 192}

La ejecución cargó 3 archivos, 3 lotes, y recalculó 3 fechas de la plata. Quedaron 177 envíos admitidos el 1 de julio, 156 el 2 y 192 el 3, 525 en total. Son menos que las 557 filas de los tres archivos porque la cuarentena se quedó con las que incumplen alguna regla y la plata dejó una fila por guía.

5. Repetir sin duplicar

¿Qué pasa si el proceso se ejecuta otra vez la misma noche, por un reintento automático o por error?

antes = spark.read.parquet(RUTAS["plata"]).count()
print("Pendientes:", pe.pendientes(spark, RUTAS).count())
print(pe.cargar_pendientes(spark, RUTAS, id_ejecucion="2026-07-03T23:30"))
print("Filas en plata antes y después de repetir:", antes, spark.read.parquet(RUTAS["plata"]).count())
Pendientes: 0
{'id_ejecucion': '2026-07-03T23:30', 'archivos': 0, 'lotes': [], 'fechas_recalculadas': 0}
Filas en plata antes y después de repetir: 525 525

No había archivos pendientes, la ejecución no hizo nada y la plata siguió con 525 filas. La carga es idempotente por la primera decisión del pipeline: cada archivo cargado quedó en el registro con su huella. Aunque hubiera habido algo pendiente, el resultado sería el mismo, porque bronce y plata se escriben reemplazando particiones y nunca agregando filas.

6. Datos tardíos

NotaDato tardío

Un dato tardío es un registro que llega en un lote posterior al que le corresponde por su fecha de negocio. Aquí, un envío admitido el 3 de julio que aparece en el archivo del 5. Un pipeline que escribiera cada lote solo en la fecha del lote lo pondría en el día equivocado; uno que solo agregara filas a la fecha de admisión podría duplicarlo si el archivo se carga dos veces.

Llegan los archivos del 4 (la versión cortada) y del 5. La celda compara la plata por fecha antes y después de cargarlos.

llegan("envios_2026-07-04.csv", "envios_2026-07-05.csv")
antes = estado_plata()
print(pe.cargar_pendientes(spark, RUTAS, id_ejecucion="2026-07-05T23:00"))
despues = estado_plata()
print(pd.DataFrame({"antes": antes, "después": despues}).fillna(0).astype(int).T.to_string())
{'id_ejecucion': '2026-07-05T23:00', 'archivos': 2, 'lotes': ['2026-07-04', '2026-07-05'], 'fechas_recalculadas': 4}
         07-01  07-02  07-03  07-04  07-05
antes      177    156    192      0      0
después    177    157    200    113    171

La ejecución cargó 2 lotes y recalculó 4 fechas, no 2. Los archivos del 4 y del 5 traían envíos tardíos admitidos el 2 y el 3 de julio, y esas fechas se recalcularon con las filas de todos los lotes. El 3 de julio pasó de 192 a 200 envíos y el 2, de 156 a 157. El 4 de julio quedó con 113 envíos, porque su archivo llegó cortado, y el 5 con 171.

7. Un archivo corregido

Al día siguiente, el sistema de admisión reenvía el archivo del 4 de julio completo, como envios_2026-07-04_v2.csv. Hay dos formas comunes de decidir qué cargar.

NotaMarca de agua

Una marca de agua (watermark) es el valor más alto que ya se procesó de una columna que siempre crece, como una fecha o un identificador. La siguiente carga toma solo lo que está por encima de la marca. Es la forma más simple de carga incremental y funciona bien cuando los datos solo se agregan y nunca se corrigen.

La celda calcula la marca de agua por lote y compara lo que cada método considera nuevo.

control = spark.read.parquet(RUTAS["control"])
marca_de_agua = control.agg(F.max("lote")).first()[0]
print("Marca de agua (último lote cargado):", marca_de_agua)

llegan("envios_2026-07-04_v2.csv")
llegados = pe.archivos_en_llegada(spark, RUTAS["llegada"])
print("Nuevos según la marca de agua (lote > marca):",
      [f["archivo"] for f in llegados.filter(F.col("lote") > marca_de_agua).collect()])
print("Nuevos según el registro de cargas (archivo y huella):",
      [f["archivo"] for f in pe.pendientes(spark, RUTAS).collect()])
Marca de agua (último lote cargado): 2026-07-05
Nuevos según la marca de agua (lote > marca): []
Nuevos según el registro de cargas (archivo y huella): ['envios_2026-07-04_v2.csv']

La marca de agua es 2026-07-05, el último lote cargado. El archivo corregido pertenece al lote 2026-07-04, que no es mayor que la marca, así que con ese método no se cargaría nunca ([]). El registro de cargas sí lo detecta: el nombre envios_2026-07-04_v2.csv no está registrado. Habría detectado también un archivo corregido que llegara con el mismo nombre, porque su huella sería otra.

antes = estado_plata()
print(pe.cargar_pendientes(spark, RUTAS, id_ejecucion="2026-07-06T09:00"))
despues = estado_plata()
print(pd.DataFrame({"antes": antes, "después": despues}).fillna(0).astype(int).T.to_string())
print()
(
    spark.read.parquet(RUTAS["bronce"]).groupBy("lote", "archivo_origen").count()
    .filter("lote = '2026-07-04'").show(truncate=False)
)
{'id_ejecucion': '2026-07-06T09:00', 'archivos': 1, 'lotes': ['2026-07-04'], 'fechas_recalculadas': 3}
         07-01  07-02  07-03  07-04  07-05
antes      177    157    200    113    171
después    177    158    205    178    171

+----------+------------------------+-----+
|lote      |archivo_origen          |count|
+----------+------------------------+-----+
|2026-07-04|envios_2026-07-04_v2.csv|200  |
+----------+------------------------+-----+

La ejecución cargó el lote del 4 y recalculó 3 fechas: el 4 de julio pasó de 113 a 178 envíos, y el 2 y el 3 sumaron uno y cinco envíos tardíos que venían en la parte que faltaba. En bronce, la partición lote=2026-07-04 tiene ahora solo las 200 filas de envios_2026-07-04_v2.csv: la sobrescritura dinámica reemplazó la versión cortada en lugar de sumarla, así que no quedaron duplicados.

8. El resto de los diez días y la prueba de la carga completa

Llegan juntos los archivos del 6 al 10, como si el proceso no hubiera corrido en cinco noches. Una ejecución los carga todos.

llegan(*[f"envios_2026-07-{dia:02d}.csv" for dia in range(6, 11)])
print(pe.cargar_pendientes(spark, RUTAS, id_ejecucion="2026-07-10T23:00"))
plata = spark.read.parquet(RUTAS["plata"])
print("Filas en plata:", plata.count(), "| guías distintas:", plata.select("guia").distinct().count())
{'id_ejecucion': '2026-07-10T23:00', 'archivos': 5, 'lotes': ['2026-07-06', '2026-07-07', '2026-07-08', '2026-07-09', '2026-07-10'], 'fechas_recalculadas': 7}
Filas en plata: 1802 | guías distintas: 1802

La ejecución cargó 5 archivos y recalculó 7 fechas, del 4 al 10 de julio, por los envíos tardíos. La plata tiene 1 802 filas y 1 802 guías distintas: ninguna guía quedó repetida, ni por los duplicados de los archivos ni por los tardíos ni por la corrección del día 4.

¿Es correcta la plata construida a pedazos? La prueba más fuerte es compararla con una carga completa: procesar de una vez todo lo que hay en bronce con las mismas funciones del módulo y comparar fila por fila con exceptAll, que devuelve las filas de una tabla que no están en la otra, contando repetidas.

bronce = spark.read.parquet(RUTAS["bronce"])
completa = pe.a_plata(pe.quitar_duplicados(pe.validar(pe.normalizar(bronce)).filter(F.size("motivos") == 0)))

columnas = ["guia", "admision", "entrega", "origen", "destino", "servicio", "operador",
            "peso_kg", "horas_transito", "a_tiempo", "lote", "archivo_origen"]
incremental = spark.read.parquet(RUTAS["plata"]).select(columnas)
completa = completa.select(columnas)
print("Filas: incremental", incremental.count(), "| carga completa", completa.count())
print("En la incremental y no en la completa:", incremental.exceptAll(completa).count())
print("En la completa y no en la incremental:", completa.exceptAll(incremental).count())
Filas: incremental 1802 | carga completa 1802
En la incremental y no en la completa: 0
En la completa y no en la incremental: 0

Las dos versiones tienen 1 802 filas y ninguna diferencia en ningún sentido. Después de cinco ejecuciones, una repetida, una con datos tardíos y otra con un archivo corregido, la carga incremental llegó exactamente al mismo resultado que reprocesar todo. Esta comparación es una buena prueba para dejar en un pipeline real: se corre de vez en cuando, por ejemplo una vez al mes, y avisa si la carga incremental se desvió.

9. El registro de cargas y los tardíos

El registro de cargas es también la bitácora del pipeline: dice qué se cargó, cuándo y con qué resultado.

(
    spark.read.parquet(RUTAS["control"])
    .select("id_ejecucion", "archivo", "bytes", "filas_leidas", "filas_cuarentena",
            F.substring("huella", 1, 10).alias("huella"))
    .orderBy("id_ejecucion", "archivo")
    .show(truncate=False)
)
+----------------+------------------------+-----+------------+----------------+----------+
|id_ejecucion    |archivo                 |bytes|filas_leidas|filas_cuarentena|huella    |
+----------------+------------------------+-----+------------+----------------+----------+
|2026-07-03T23:00|envios_2026-07-01.csv   |21253|180         |9               |d6538bcd7e|
|2026-07-03T23:00|envios_2026-07-02.csv   |20321|171         |9               |dfce96d9d7|
|2026-07-03T23:00|envios_2026-07-03.csv   |24489|206         |8               |5bcca7ae91|
|2026-07-05T23:00|envios_2026-07-04.csv   |14235|120         |6               |c09db54627|
|2026-07-05T23:00|envios_2026-07-05.csv   |22670|192         |11              |0f9c47d00c|
|2026-07-06T09:00|envios_2026-07-04_v2.csv|23662|200         |13              |803725a84a|
|2026-07-10T23:00|envios_2026-07-06.csv   |23240|195         |10              |408eea5c17|
|2026-07-10T23:00|envios_2026-07-07.csv   |22908|194         |14              |5371dfc7b9|
|2026-07-10T23:00|envios_2026-07-08.csv   |23292|196         |14              |62e1b99cf2|
|2026-07-10T23:00|envios_2026-07-09.csv   |21937|185         |15              |b0fe57aeed|
|2026-07-10T23:00|envios_2026-07-10.csv   |25805|218         |14              |1366638a5d|
+----------------+------------------------+-----+------------+----------------+----------+

El registro tiene 11 filas, una por archivo, en 4 ejecuciones; la ejecución repetida no dejó filas porque no cargó nada. La versión cortada del día 4 sigue registrada, con 120 filas leídas, aunque su lote ya fue reemplazado: el registro es un historial de lo que pasó, no el estado actual. Cada archivo dejó entre 6 y 15 filas en cuarentena.

La plata conserva el lote en que llegó cada envío, así que se puede medir cuántos llegaron tarde.

tardias = (
    spark.read.parquet(RUTAS["plata"])
    .withColumn("llego", F.when(F.col("lote") == F.col("fecha"), "el mismo día")
                .otherwise("en un lote posterior"))
    .groupBy("fecha").pivot("llego", ["el mismo día", "en un lote posterior"]).count()
    .na.fill(0).orderBy("fecha").toPandas()
)
tardias["fecha"] = tardias["fecha"].astype(str).str[5:]
print(tardias.to_string(index=False))
print()
print("Envíos de la plata que llegaron en un lote posterior:", int(tardias["en un lote posterior"].sum()))
fecha  el mismo día  en un lote posterior
07-01           168                     9
07-02           155                     3
07-03           192                    13
07-04           171                     8
07-05           171                    14
07-06           171                     9
07-07           169                     8
07-08           171                     7
07-09           161                     7
07-10           195                     0

Envíos de la plata que llegaron en un lote posterior: 78

En la plata hay 78 envíos que llegaron en un lote posterior al de su fecha de admisión; los otros 3 de los 81 tardíos generados quedaron en cuarentena o eran duplicados. El 3 y el 5 de julio son los días con más tardíos, 13 y 14. El 10 de julio no tiene ninguno, porque no hubo lotes después.

figura, eje = plt.subplots(figsize=(8, 3.8))
eje.bar(tardias["fecha"], tardias["el mismo día"], label="Llegó en el lote de su día")
eje.bar(tardias["fecha"], tardias["en un lote posterior"], bottom=tardias["el mismo día"],
        label="Llegó en un lote posterior", hatch="//", edgecolor="white")
eje.set_xlabel("Fecha de admisión (julio de 2026)")
eje.set_ylabel("Envíos en la plata")
eje.legend(frameon=False, loc="upper center", bbox_to_anchor=(0.5, -0.2), ncol=2)
plt.tight_layout()
plt.show()
Barras apiladas para los días 1 a 10 de julio. Casi toda la barra de cada día corresponde a envíos que llegaron el mismo día; una franja pequeña encima, en los días 1 a 9, son envíos que llegaron en un lote posterior. El día 10 no tiene franja porque no hubo lotes después.
Figura 19.1: Envíos de la plata por fecha de admisión, según si llegaron en el lote de ese día o en uno posterior

En la figura, las franjas rayadas suman los 78 envíos tardíos; la más alta es la del 5 de julio, con 14. Son envíos que una carga por lote habría puesto en el día equivocado, o que una carga que solo agrega filas habría tenido que buscar en días anteriores. El pipeline los ubicó en su fecha de admisión porque recalcula esas fechas completas.

10. Lo que este pipeline no resuelve

El pipeline del capítulo es correcto e idempotente con archivos Parquet simples, pero tiene límites que conviene conocer:

Límite Por qué pasa Qué se usa en la práctica
Recalcular una fecha completa para corregir unas pocas filas Parquet no permite modificar filas: solo escribir archivos nuevos Formatos de tabla con MERGE, como Apache Iceberg (capítulo de lakehouse)
Si la ejecución falla a la mitad de escribir la plata, una fecha puede quedar a medias hasta la siguiente ejecución La escritura de varias particiones no es atómica Tablas con transacciones (Iceberg), o escribir en una carpeta temporal y renombrar
Dos ejecuciones al mismo tiempo pueden pisarse No hay bloqueo entre procesos Un orquestador que no lance una ejecución si la anterior sigue corriendo (capítulo de Airflow)
Solo lee archivos La fuente de BITLogística deja CSV Bases de datos con spark.read.jdbc y una marca de agua sobre una columna como actualizado_en; APIs con paginación por fecha
Nadie revisa la calidad antes de publicar Las reglas separan filas, pero un archivo completo puede venir mal Métricas de calidad y una puerta que detiene la publicación (capítulo siguiente)

La marca de agua sigue siendo útil en fuentes que solo agregan datos, como un registro de eventos con un identificador creciente. El registro de cargas por huella es más robusto cuando la fuente reenvía o corrige archivos, que es el caso de BITLogística.

Limpiar

La celda cierra la sesión. /bitlogistica/ingesta se conserva, porque el capítulo de calidad la usa, y también pipeline_envios.py y entregas_julio/ en la carpeta del notebook. Para borrar la zona de ingesta a mano: dc exec spark-client /opt/hadoop/bin/hdfs dfs -rm -r /bitlogistica/ingesta.

spark.stop()
print("Sesión cerrada. /bitlogistica/ingesta queda para el capítulo de calidad;",
      "pipeline_envios.py y entregas_julio/ quedan en la carpeta del notebook.")
Sesión cerrada. /bitlogistica/ingesta queda para el capítulo de calidad; pipeline_envios.py y entregas_julio/ quedan en la carpeta del notebook.

La sesión quedó cerrada. En HDFS siguen la plata de julio, con 1 802 envíos, y el registro de cargas, con 11 archivos, para el capítulo siguiente.

Práctica

Para hacer estos ejercicios, ejecuta de nuevo las celdas de las secciones 1 a 3 (la sesión, el módulo, la importación con el borrado de la zona de ingesta y la generación de archivos).

  1. Todo junto. Haz llegar los once archivos de una vez y ejecuta una sola carga. ¿Cuántas filas tiene la plata? ¿Qué versión del día 4 quedó en bronce?
  2. Mismo nombre, otro contenido. Carga los días 1 a 3, cambia a mano una fila de entregas_julio/envios_2026-07-02.csv, vuelve a hacerlo llegar con el mismo nombre y ejecuta la carga. ¿El pipeline lo detecta? ¿Qué cambia en el registro?
  3. Sin sobrescritura dinámica. En una sesión nueva, deja partitionOverwriteMode en static, carga los días 1 a 3 y después el 4 y el 5. ¿Qué pasó con los lotes del 1 al 3 en bronce?
  4. Marca de agua por fecha de admisión. Calcula la marca de agua como la fecha de admisión más alta de la plata después de cargar los días 1 a 3, y filtra con ella las filas del archivo del día 5. ¿Cuántos envíos tardíos se perderían?
  5. Ejecución interrumpida. Simula un fallo: copia el código de cargar_pendientes en una celda, ejecútalo hasta escribir bronce y detente antes del registro. ¿Qué hace la siguiente ejecución normal?
  6. Un mes más. Cambia el generador para producir los días 11 a 15 y cárgalos. Comprueba con la carga completa que la plata sigue cuadrando.
  1. La plata tiene las mismas 1 802 filas que con cinco ejecuciones. Los dos archivos del día 4 están pendientes a la vez; el pipeline se queda con el último por nombre, envios_2026-07-04_v2.csv, y bronce tiene solo sus 200 filas. El registro guarda los dos archivos.
  2. Sí: el nombre ya está registrado, pero con otra huella, así que la unión anti lo devuelve como pendiente. El registro queda con dos filas para el mismo nombre, con huellas distintas, y la plata del día 2 se recalcula con el contenido nuevo.
  3. Con static, la escritura de bronce de los lotes 4 y 5 borra la tabla completa, y los lotes 1 a 3 desaparecen. Lo mismo pasa en la plata: quedan solo las fechas recalculadas (del 2 al 5 de julio), el 1 de julio se pierde, y el 2 y el 3 se recalculan sin las filas de sus propios lotes. Por eso la opción dynamic es parte del diseño, no un detalle.
  4. La marca sería el 3 de julio. Los envíos del archivo del 5 admitidos el 3 no pasan el filtro «fecha mayor que la marca» y se pierden; con los datos del capítulo son unos pocos, pero se pierden en silencio, que es lo peor.
  5. Los archivos siguen pendientes porque el registro se escribe al final. La siguiente ejecución reemplaza las particiones de bronce de esos lotes (sobrescritura dinámica), recalcula sus fechas y registra los archivos. El resultado es el mismo que sin el fallo: esa es la idempotencia que da escribir el registro al final.
  6. Hay que cambiar el filtro de días en la celda del generador y los nombres de los archivos. La comparación con la carga completa debe dar 0 filas de diferencia en los dos sentidos.

Errores frecuentes

Síntoma Causa Arreglo
Al cargar un lote desaparecen los lotes anteriores La sobrescritura de particiones está en static, el valor por defecto. spark.sql.sources.partitionOverwriteMode en dynamic.
Repetir la carga duplica filas La escritura usa mode("append") sin comprobar qué se cargó antes. Registro de cargas y escrituras que reemplazan particiones.
Un archivo corregido nunca se carga La carga usa una marca de agua y el archivo es de un lote anterior. Comparar nombre y huella contra el registro de cargas.
Un envío aparece en el día equivocado La plata se escribe por lote en lugar de por fecha de negocio. Particionar la plata por fecha de admisión y recalcular las fechas afectadas.
ModuleNotFoundError: No module named 'generar_envios' El generador no está en la carpeta del notebook. Copiarlo desde el zip de talleres a ~/hdfs-docker-lab/notebooks.
ModuleNotFoundError: No module named 'pipeline_envios' No se ejecutó la celda con %%writefile. Ejecutarla antes de importar el módulo.
Después de editar el módulo, el notebook sigue usando la versión vieja Python importa un módulo una sola vez por sesión. importlib.reload(pe), como en la celda de importación.

Preguntas de comprensión

  1. ¿Por qué el registro de cargas se escribe al final de la ejecución y no al principio?
  2. ¿Por qué la plata se particiona por fecha de admisión y la bronce por lote?
  3. Si una fuente solo agrega registros con un identificador creciente y nunca corrige nada, ¿qué método conviene para detectar lo nuevo?
  4. ¿Qué garantiza que, entre dos versiones de una guía, quede la más reciente?
  5. ¿Qué pierde un pipeline que cada noche reprocesa todo el histórico, si el resultado es el mismo?
  1. Porque el registro dice «este archivo ya quedó cargado». Si se escribiera al principio y la ejecución fallara después, el archivo quedaría marcado como cargado sin estarlo y no se volvería a intentar. Escrito al final, un fallo deja el archivo pendiente y la siguiente ejecución lo carga completo.
  2. Porque cada capa responde a una pregunta distinta. En bronce, la unidad es lo que llegó: un lote se reemplaza completo cuando llega corregido. En plata, la unidad es el negocio: los informes consultan por fecha de admisión, y un envío tardío tiene que quedar en su fecha, no en la del archivo.
  3. Una marca de agua sobre el identificador: guardar el máximo cargado y leer solo lo que está por encima. Es más simple y barato que calcular huellas, y en esa fuente no hay correcciones que se le escapen.
  4. quitar_duplicados ordena las filas de cada guía por lote y por nombre de archivo, de forma descendente, y se queda con la primera. Como la plata se recalcula con todos los lotes de bronce, la versión del lote más reciente siempre está disponible para ganar.
  5. Tiempo y recursos, que crecen con el histórico: con tres años de archivos diarios, cada ejecución leería más de mil archivos para cambiar unos cuantos. La carga completa sigue siendo útil como verificación ocasional y para reconstruir la plata si cambian las reglas.

Glosario

Término Significado en este capítulo
Pipeline de ingesta Proceso que lleva los datos desde la zona de llegada hasta las capas limpias.
Carga completa Reprocesar todo el histórico en cada ejecución.
Carga incremental Procesar solo lo nuevo o lo que cambió desde la ejecución anterior.
Lote Unidad de llegada; aquí, el archivo de un día.
Idempotencia Propiedad de una operación que deja el mismo resultado si se repite.
Huella Código calculado a partir del contenido de un archivo, que cambia si cambia un byte.
Registro de cargas Tabla con una fila por archivo procesado: huella, filas y ejecución.
Marca de agua Valor más alto procesado de una columna creciente, usado para leer solo lo posterior.
Dato tardío Registro que llega en un lote posterior al de su fecha de negocio.
Sobrescritura dinámica Reemplazar solo las particiones presentes en los datos que se escriben.
Reproceso Volver a cargar un lote, por ejemplo cuando llega corregido.
Módulo Archivo .py con funciones que otros programas importan.

Referencias para profundizar

Resumen

Con los archivos diarios de julio de BITLogística construiste un pipeline de ingesta incremental en un módulo de Python reutilizable. El registro de cargas, con el nombre y la huella MD5 de cada archivo, decidió qué cargar. Una ejecución repetida no cambió nada: la plata siguió con 525 filas. La marca de agua por lote no detectó el archivo corregido del 4 de julio y el registro sí. La sobrescritura dinámica reemplazó la versión cortada de ese lote en bronce en lugar de sumarla. Al recalcular completas las fechas afectadas, los 78 envíos tardíos quedaron en su fecha de admisión. Después de cinco ejecuciones, la plata tenía 1 802 envíos, una fila por guía, y coincidió fila por fila con una carga completa.

El capítulo siguiente, Calidad, pruebas y trazabilidad, prueba las funciones de este módulo con datos pequeños y conocidos, agrega métricas de calidad por lote y una puerta que detiene la publicación, y responde de qué archivo salió cada número.