Excepciones: cuando el archivo miente

from pathlib import Path


def leer(nombre):
    """Devuelve la cantidad de lineas, o None si el archivo no esta."""
    print("--- intentando con", nombre)
    try:
        f = open(nombre, encoding="utf-8")
    except FileNotFoundError:
        # except: solo corre si esa excepcion ocurrio.
        print("  except : no existe, sigo sin ese archivo")
        return None
    else:
        # else: solo corre si el try NO fallo. Aca va el trabajo que
        # depende del exito, y asi el try queda con una sola linea.
        cuantas = sum(1 for _ in f)
        print("  else   :", cuantas, "lineas")
        return cuantas
    finally:
        # finally: corre SIEMPRE. Con exito, con error, y tambien
        # cuando el return ya se ejecuto.
        print("  finally: cierro lo que haya que cerrar")
        try:
            f.close()
        except NameError:
            pass


leer("estudiantes_notas.csv")
leer("notas_del_anio_pasado.csv")

print()
print("El try envuelve UNA operacion riesgosa, no el programa entero:")
print("si adentro del try hubiera 20 lineas, el except no sabria cual fallo.")

# Las excepciones forman un arbol. Atrapar una clase atrapa a todas
# sus descendientes, y por eso importa cual nombras.


def cadena(clase):
    """La linea de herencia de una excepcion, de la mas concreta a Exception."""
    nombres = []
    for c in clase.__mro__:
        nombres.append(c.__name__)
        if c is Exception:
            break
    return " -> ".join(nombres)


print("FileNotFoundError:", cadena(FileNotFoundError))
print("PermissionError  :", cadena(PermissionError))
print("ValueError       :", cadena(ValueError))
print("KeyError         :", cadena(KeyError))
print("IsADirectoryError:", cadena(IsADirectoryError))

print()
print("Por eso un solo except OSError cubre archivo inexistente y sin permiso:")
for nombre in ("no_existe.csv", "."):
    try:
        open(nombre, encoding="utf-8").read()
    except OSError as error:
        print("  ", nombre, "->", type(error).__name__)
print("   (en Linux la segunda da IsADirectoryError: tambien es un OSError)")

print()
print("Atrapar de mas es peor que no atrapar: aca hay un error de tipeo.")
fila = {"legajo": "L2601", "nota_1": "9.7"}
try:
    valor = float(fila["nota_l"])   # ojo: ele minuscula, no uno
except Exception:
    print("   except Exception -> 'dato invalido'")
    print("   ...pero el dato estaba bien: la que fallo fue la clave del dict.")

try:
    valor = float(fila["nota_l"])
except ValueError:
    print("   nunca llega aca")
except KeyError as error:
    print("   except KeyError ->", error, "| el mensaje ahora dice la verdad")

import csv

# Un try/except solo te protege de lo que efectivamente falla. Hay
# cadenas invalidas que float() acepta sin decir nada.
for texto in ("9.7", "-", "N/A", "", "NaN", "nan", "infinity", " 7 ", "7.0"):
    try:
        print(f"float({texto!r:>12}) = {float(texto)!r}")
    except ValueError as error:
        print(f"float({texto!r:>12}) -> ValueError: {error}")

print()
print("NaN e infinity pasan el try/except y contaminan todo lo que toquen:")
print("   9.7 + float('NaN') =", 9.7 + float("NaN"))
print("   float('NaN') == float('NaN') ->", float("NaN") == float("NaN"))

print()
print("Asi se ve en un archivo real: la columna nota_3 de 40 estudiantes.")
with open("estudiantes_notas.csv", encoding="utf-8", newline="") as f:
    filas = list(csv.DictReader(f))

notas = []
descartadas = 0
for fila in filas:
    try:
        notas.append(float(fila["nota_3"]))
    except ValueError:
        descartadas += 1

print("   filas:", len(filas), "| descartadas por ValueError:", descartadas)
print("   promedio:", sum(notas) / len(notas))
print("   ...el promedio es nan: el 'NaN' del archivo entro como numero valido.")

print()
# La validacion tiene que ser una decision explicita, no el efecto
# secundario de que float() se haya quejado o no.
NULOS = {"", "-", "N/A", "NaN", "null", "NA"}
buenas = []
for fila in filas:
    crudo = fila["nota_3"].strip()
    if crudo in NULOS:
        continue
    valor = float(crudo)
    if not 0 <= valor <= 10:
        continue
    buenas.append(valor)

print("   con una lista explicita de nulos:", len(buenas), "notas validas")
print("   promedio:", round(sum(buenas) / len(buenas), 2))

print()
print("Los 6 valores problematicos de nota_3, en tres niveles de disimulo:")
print("   4 hacen fallar a float()   : '-' (x2), '' , 'N/A'")
print("   1 pasa como numero valido  : 'NaN' -> nan, y arruina el promedio")
print("   1 pasa y es un numero real : -1.0, que no es una nota posible")
print("Solo el primer nivel lo detecta un try/except. Los otros dos hay que")
print("buscarlos: por eso validar no es lo mismo que atrapar excepciones.")

import csv
import traceback


class FilaInvalida(Exception):
    """Una fila del archivo que no cumple las reglas del negocio.

    Guarda el motivo con el vocabulario cerrado del curso, para que el
    informe de rechazos se pueda contar y comparar.
    """

    def __init__(self, motivo, columna, valor):
        super().__init__(f"{motivo} en {columna}: {valor!r}")
        self.motivo = motivo
        self.columna = columna
        self.valor = valor


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


def nota(fila, columna):
    crudo = fila[columna].strip()
    if crudo in NULOS:
        raise FilaInvalida("ausente", columna, crudo)
    try:
        valor = float(crudo)
    except ValueError as error:
        # from error engancha la causa: el traceback muestra las dos.
        raise FilaInvalida("no_numerico", columna, crudo) from error
    if not 0 <= valor <= 10:
        raise FilaInvalida("fuera_de_rango", columna, valor)
    return valor


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

validas, rechazos = [], []
for fila in filas:
    try:
        notas = [nota(fila, c) for c in ("nota_1", "nota_2", "nota_3")]
    except FilaInvalida as error:
        rechazos.append((fila["legajo"], error.motivo, error.columna))
    else:
        validas.append((fila["legajo"], round(sum(notas) / 3, 2)))

print("validas:", len(validas), "| rechazadas:", len(rechazos))
print()
for legajo, motivo, columna in rechazos:
    print(f"  {legajo}  {motivo:<15} {columna}")

print()
print("El motivo viaja DENTRO de la excepcion, no en el texto del mensaje:")
print("por eso se puede contar, ordenar y escribir a un CSV de rechazos.")

print()
print("Y asi se ve el encadenado de raise ... from:")
try:
    nota({"nota_1": "N/A", "legajo": "L2613"}, "nota_1")
except FilaInvalida:
    pass
try:
    nota({"nota_1": "ocho", "legajo": "L9999"}, "nota_1")
except FilaInvalida:
    for linea in traceback.format_exc().splitlines():
        if linea.startswith(("ValueError", "FilaInvalida", "The above")):
            print("  ", linea)