Las cuatro capas de error

import re

# El patron describe la FORMA: seis campos separados por espacios.
# Que cada campo sea de veras lo que dice ser es otra pregunta.
PATRON = re.compile(
    r"^(?P<fecha>\S+) (?P<ip>\S+) (?P<metodo>\S+) "
    r"(?P<ruta>\S+) (?P<estado>\S+) (?P<ms>\S+)$")

FECHA = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
METODOS = {"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"}

CASOS = [
    "2026-08-24T08:01:01 10.0.0.28 PUT /login 200 102",
    "2026-08-24T08:04:12 10.0.0.9 DELETE /reportes 200",
    "fecha_invalida 10.0.0.6 GET / 200 45",
    "2026-08-24T08:07:33 10.0.0.4 TRACE /admin 200 61",
    "2026-08-24T08:09:02 10.0.0.7 GET /home 200 -30",
]

for linea in CASOS:
    print(repr(linea))

    # Capa 2, parseo: ¿tiene la forma esperada?
    m = PATRON.match(linea)
    if m is None:
        print("   2 parseo     -> RECHAZADA: no tiene 6 campos")
        print()
        continue
    campos = m.groupdict()
    print("   2 parseo     -> ok, 6 campos")

    # Capa 3, validacion: ¿cada campo es lo que dice ser?
    problemas = []
    if not FECHA.fullmatch(campos["fecha"]):
        problemas.append("fecha_invalida")
    if campos["metodo"] not in METODOS:
        problemas.append("dominio_desconocido (" + campos["metodo"] + ")")
    try:
        if int(campos["ms"]) < 0:
            problemas.append("negativo_incoherente (ms)")
    except ValueError:
        problemas.append("no_numerico (ms)")
    if problemas:
        print("   3 validacion -> RECHAZADA:", "; ".join(problemas))
        print()
        continue

    print("   3 validacion -> ok")
    print("   4 negocio    -> ya se puede contar, promediar y agrupar")
    print()

print("La capa 1, la de lectura, ya ocurrio antes de todo esto: el archivo")
print("existe, se abrio con su encoding y el JSON parseo bien.")
print()
print("Cada capa supone que la anterior salio bien, y por eso el orden es")
print("obligatorio: preguntar si el metodo es valido antes de saber si hay")
print("un metodo no tiene sentido. Fijate que la linea del '-30' tiene la")
print("forma correcta: solo la capa 3 puede rechazarla.")

import collections
import csv
from pathlib import Path

# La lista no es un capricho: es lo que aparece de verdad en los datos.
CANDIDATOS = ["", "-", "N/A", "NaN", "null", "NA", "None", "n/a", "?"]

conteo = collections.Counter()
por_archivo = collections.defaultdict(set)

for ruta in sorted(Path(".").glob("*.csv")):
    with open(ruta, encoding="utf-8", newline="") as f:
        for fila in csv.DictReader(f):
            for valor in fila.values():
                if valor is not None and valor.strip() in CANDIDATOS:
                    token = valor.strip()
                    conteo[token] += 1
                    por_archivo[token].add(ruta.name)

print("token   celdas  archivos")
for token in CANDIDATOS:
    marca = "" if conteo[token] else "   <- no aparece nunca"
    print(f"{token!r:>7} {conteo[token]:>7} {len(por_archivo[token]):>9}{marca}")

print()
print("total de celdas ausentes:", sum(conteo.values()))

print()
print("Los cinco que si aparecen son la constante NULOS del curso:")
NULOS = {"", "-", "N/A", "NaN", "null"}
print("  ", sorted(NULOS))

print()
print("Y no estan repartidos parejo: cada generador sembro los suyos.")
for token in sorted(NULOS):
    archivos = sorted(por_archivo[token])
    print(f"  {token!r:>6} en {len(archivos)} archivo(s):",
          ", ".join(a.replace('.csv', '') for a in archivos[:4]),
          "..." if len(archivos) > 4 else "")

print()
print("Por eso la lista va escrita en el codigo, arriba y en un solo lugar.")
print("Adivinarla archivo por archivo es como se pierden datos en silencio.")

import csv
import statistics

NULOS = {"", "-", "N/A", "NaN", "null"}

with open("transacciones_categorias.csv", encoding="utf-8", newline="") as f:
    filas = list(csv.DictReader(f))


def numero(texto):
    """El importe como float, o None si no se puede."""
    crudo = texto.strip()
    if crudo in NULOS:
        return None
    try:
        return float(crudo)
    except ValueError:
        return None


valores = [numero(x["importe"]) for x in filas]
usables = [v for v in valores if v is not None]
sin_dato = [x["id"] for x, v in zip(filas, valores) if v is None]

print("filas:", len(filas), "| importes usables:", len(usables),
      "| sin importe:", len(sin_dato))
print("ids sin importe:", ", ".join(sin_dato))
print()

media = statistics.mean(usables)
mediana = statistics.median(usables)

print("1. DESCARTAR: la fila sin importe no participa de nada.")
print("   total:", round(sum(usables), 2), "| filas:", len(usables))
print("2. IMPUTAR: se completa el hueco. Con que, es otra decision.")
print("   con la media  :", round(sum(usables) + len(sin_dato) * media, 2))
print("   con la mediana:", round(sum(usables) + len(sin_dato) * mediana, 2))
print("3. INFORMAR: se descarta Y queda escrito que se descarto.")
print("   total:", round(sum(usables), 2), "+ una tabla de 6 rechazos")

print()
print("La media y la mediana de esta columna no se parecen en nada:")
print("   media  :", round(media, 2))
print("   mediana:", round(mediana, 2))
print("   maximo :", max(usables))
print("   sin ese unico valor, la media seria:",
      round(statistics.mean(sorted(usables)[:-1]), 2))

print()
print("Un solo importe de 5.000.000 mueve la media 34.000 pesos por fila.")
print("Imputar con la media reparte ese atipico entre los seis huecos:")
print("la eleccion del relleno importa tanto como la de imputar o no.")

print()
print("Ninguna de las tres politicas es 'la correcta'. La incorrecta es la")
print("cuarta: aplicar una de las tres sin dejar dicho cual fue.")

import collections
import csv
import re

# Los diez motivos del curso. Cerrado: si un defecto no entra en
# ninguno, se discute el vocabulario, no se inventa una redaccion.
MOTIVOS = [
    "ausente", "no_numerico", "fuera_de_rango", "fecha_invalida",
    "dominio_desconocido", "duplicado", "huerfano",
    "negativo_incoherente", "atipico", "restriccion_violada",
]

NULOS = {"", "-", "N/A", "NaN", "null"}
FECHA = re.compile(r"\d{4}-\d{2}-\d{2}")
TIPOS = {"ingreso", "gasto"}
TECHO = 100000.0


def revisar(fila, vistos):
    """Todos los defectos de la fila, como (motivo, columna)."""
    fallas = []
    if fila["id"] in vistos:
        fallas.append(("duplicado", "id"))
    if fila["categoria"].strip() in NULOS:
        fallas.append(("ausente", "categoria"))
    if not FECHA.fullmatch(fila["fecha"].strip()):
        fallas.append(("fecha_invalida", "fecha"))
    if fila["tipo"].strip() not in TIPOS:
        fallas.append(("dominio_desconocido", "tipo"))
    crudo = fila["importe"].strip()
    if crudo in NULOS:
        fallas.append(("ausente", "importe"))
    else:
        try:
            valor = float(crudo)
        except ValueError:
            fallas.append(("no_numerico", "importe"))
        else:
            if valor < 0:
                fallas.append(("negativo_incoherente", "importe"))
            elif valor > TECHO:
                fallas.append(("atipico", "importe"))
    return fallas


with open("transacciones_categorias.csv", encoding="utf-8", newline="") as f:
    filas = list(csv.DictReader(f))

conteo = collections.Counter()
rechazadas, vistos = [], set()
for fila in filas:
    fallas = revisar(fila, vistos)
    vistos.add(fila["id"])
    if fallas:
        rechazadas.append((fila["id"], fallas))
        for motivo, columna in fallas:
            conteo[(motivo, columna)] += 1

print("filas:", len(filas), "| con al menos un defecto:", len(rechazadas))
print()
print("motivo                columna     casos")
for motivo in MOTIVOS:
    for (m, columna), cuantos in sorted(conteo.items()):
        if m == motivo:
            print(f"{motivo:<21} {columna:<11} {cuantos:>5}")

print()
print("Los motivos que NO aparecen en este archivo:")
presentes = {m for m, _ in conteo}
print("  ", ", ".join(m for m in MOTIVOS if m not in presentes))
print("Que el vocabulario sea mas grande que el archivo es lo correcto:")
print("es el mismo en los 39 ejercicios, y por eso los informes de")
print("rechazos se pueden comparar entre si.")

print()
print("las", len(rechazadas), "filas rechazadas, en detalle:")
for identificador, fallas in rechazadas:
    detalle = "; ".join(f"{m} ({c})" for m, c in fallas)
    print(f"  {identificador}  {detalle}")