cfasig 0.1.0__py3-none-any.whl

cfasig/__init__.py

@@ -0,0 +1,122 @@
+"""
+cfasig — Wrapper simple sobre geopandas/shapely para tareas de SIG.
+
+La idea es que operaciones comunes (cargar, recortar, disolver, buffer,
+combinar, guardar...) se llamen con una sola función en español, sin
+tener que recordar la sintaxis de geopandas cada vez.
+
+Uso rápido:
+
+    import cfasig as sig
+
+    ejido = sig.cargar("ejido.shp")
+    hidro = sig.cargar("hidrologia.shp")
+
+    hidro = sig.reproyectar(hidro, 32613)
+    hidro = sig.recortar(hidro, ejido)
+    hidro = sig.disolver(hidro)
+    hidro = sig.buffer(hidro, 20)
+    sig.guardar(hidro, "salida.shp")
+"""
+
+from .archivo import (
+    cargar,
+    cargar_puntos,
+    guardar,
+    convertir,
+    cargar_waypoints,
+    cargar_tracks,
+)
+from .proyeccion import reproyectar, asegurar_crs
+from .campos import campo_seguro
+from .geometria import (
+    recortar,
+    disolver,
+    buffer,
+    puntos_a_linea,
+    puntos_a_poligono,
+    linea_a_poligono,
+    quitar_solape,
+    combinar,
+    crear_cuadro,
+    limpiar_vacias,
+    reparar_geometrias,
+    calcular_superficie,
+    intersectar,
+    unir_atributos,
+    calcular_longitud,
+    simplificar,
+    cerrar_microhuecos,
+    subdividir_por_area,
+    fusionar_menores,
+)
+from .raster import (
+    cargar_raster,
+    guardar_raster,
+    recortar_raster,
+    rellenar_nodata,
+    remuestrear,
+    interpolar_mde,
+    rasterizar,
+    quemar_cauces,
+    combinar_categorias,
+    poligonizar,
+    acondicionar_mde,
+    direccion_flujo,
+    acumulacion_flujo,
+    etiquetar_cuencas,
+    calcular_aspecto,
+)
+
+__all__ = [
+    # archivo
+    "cargar",
+    "cargar_puntos",
+    "guardar",
+    "convertir",
+    "cargar_waypoints",
+    "cargar_tracks",
+    # proyeccion
+    "reproyectar",
+    "asegurar_crs",
+    # campos
+    "campo_seguro",
+    # geometria
+    "recortar",
+    "disolver",
+    "buffer",
+    "puntos_a_linea",
+    "puntos_a_poligono",
+    "linea_a_poligono",
+    "quitar_solape",
+    "combinar",
+    "crear_cuadro",
+    "limpiar_vacias",
+    "reparar_geometrias",
+    "calcular_superficie",
+    "intersectar",
+    "unir_atributos",
+    "calcular_longitud",
+    "simplificar",
+    "cerrar_microhuecos",
+    "subdividir_por_area",
+    "fusionar_menores",
+    # raster
+    "cargar_raster",
+    "guardar_raster",
+    "recortar_raster",
+    "rellenar_nodata",
+    "remuestrear",
+    "interpolar_mde",
+    "rasterizar",
+    "quemar_cauces",
+    "combinar_categorias",
+    "poligonizar",
+    "acondicionar_mde",
+    "direccion_flujo",
+    "acumulacion_flujo",
+    "etiquetar_cuencas",
+    "calcular_aspecto",
+]
+
+__version__ = "0.1.0"

cfasig/archivo.py

@@ -0,0 +1,375 @@
+"""Entrada y salida de capas (leer/escribir archivos vectoriales)."""
+
+import os
+import re
+import warnings
+from collections.abc import Iterator
+from contextlib import contextmanager, nullcontext
+from os import PathLike
+
+import geopandas as gpd
+import pandas as pd
+from shapely.geometry import LineString, MultiLineString
+from shapely.geometry.base import BaseGeometry
+
+from .proyeccion import _exigir_crs
+
+# Formatos que exigen WGS84 lon/lat (EPSG:4326) y driver propio de GDAL.
+# GPX y KML/KMZ solo hablan geográficas; hay que reproyectar al exportar.
+_DRIVERS_GEO = {".gpx": "GPX", ".kml": "LIBKML", ".kmz": "LIBKML"}
+
+# Avisos de GDAL/pyogrio (en inglés) traducidos: fragmento a buscar -> texto ES.
+_AVISOS_ES = {
+    "Column names longer than 10 characters": "el formato SHP recorta los nombres de columna a 10 caracteres",
+    "created as String field": "GPX guardó un campo de fecha/hora como texto (limitación del formato)",
+    "Normalized/laundered field name": "GPX renombró un campo para ajustarlo a su esquema fijo",
+    "More than one layer found": "el archivo tiene varias capas; se leyó la predeterminada (usa capa= para elegir otra)",
+}
+
+
+@contextmanager
+def _traducir_avisos() -> Iterator[None]:
+    """Captura avisos de GDAL/pyogrio y los reemite en español.
+
+    Los conocidos salen como 'Aviso: ...'; los desconocidos se reemiten tal cual
+    para no ocultar nada nuevo.
+    """
+    with warnings.catch_warnings(record=True) as capturados:
+        warnings.simplefilter("always")
+        yield
+    for a in capturados:
+        es = next((v for k, v in _AVISOS_ES.items() if k in str(a.message)), None)
+        if es:
+            print(f"Aviso: {es}")
+        else:
+            warnings.warn(a.message, a.category)
+
+
+@contextmanager
+def _env(var: str, valor: str) -> Iterator[None]:
+    """Fija una variable de entorno solo durante el bloque y luego la restaura."""
+    previo = os.environ.get(var)
+    os.environ[var] = valor
+    try:
+        yield
+    finally:
+        if previo is None:
+            del os.environ[var]
+        else:
+            os.environ[var] = previo
+
+
+def cargar(
+    ruta: str | PathLike[str], capa: str | None = None, mostrar: bool = True
+) -> gpd.GeoDataFrame:
+    """Carga una capa vectorial (.shp, .gpkg, .geojson, .gpx...) como GeoDataFrame.
+
+    Parámetros
+    ----------
+    ruta : str
+        Ruta al archivo.
+    capa : str, opcional
+        Nombre de la capa a leer. Necesario en formatos multicapa: GPX
+        (waypoints/routes/tracks) y GeoPackage con varias capas. Si es None
+        lee la primera/única.
+    mostrar : bool
+        Si True imprime nº de entidades y CRS.
+
+    Devuelve
+    --------
+    GeoDataFrame
+    """
+    if not os.path.exists(ruta):
+        raise FileNotFoundError(f"no existe la ruta '{ruta}'")
+    with _traducir_avisos():
+        gdf = gpd.read_file(ruta, layer=capa)
+    if mostrar:
+        print(f"Cargado '{ruta}': {len(gdf)} entidades | CRS: {gdf.crs}")
+    if len(gdf) == 0:
+        print(f"Aviso: '{ruta}' no tiene entidades")
+    return gdf
+
+
+def cargar_puntos(
+    ruta: str | PathLike[str],
+    x: str = "x",
+    y: str = "y",
+    epsg: int | None = None,
+    orden: str | None = None,
+    mostrar: bool = True,
+) -> gpd.GeoDataFrame:
+    """Carga un CSV o Excel con columnas de coordenadas como capa de puntos.
+
+    Parámetros
+    ----------
+    x, y : str
+        Nombres de las columnas con la coordenada X (este/lon) e Y (norte/lat).
+    epsg : int, opcional
+        CRS de esas coordenadas (p.ej. 32613 para UTM 13N, 4326 para lon/lat).
+        El archivo de texto no lo trae, así que se define aquí. Sin él la capa
+        queda sin CRS y no podrás reproyectar ni medir áreas.
+    orden : str, opcional
+        Columna de secuencia por la que ordenar las filas antes de armar la
+        capa. Si es None se respeta el orden del archivo. Solo importa si luego
+        conviertes los puntos a línea o polígono.
+
+    Devuelve
+    --------
+    GeoDataFrame de puntos con todas las columnas del archivo como atributos.
+    """
+    if not os.path.exists(ruta):
+        raise FileNotFoundError(f"no existe la ruta '{ruta}'")
+    ext = os.path.splitext(str(ruta))[1].lower()
+    leer = pd.read_excel if ext in (".xlsx", ".xls") else pd.read_csv
+    df = leer(ruta)
+    for col in (x, y):
+        if col not in df.columns:
+            raise ValueError(
+                f"el archivo no tiene la columna '{col}'; columnas: {list(df.columns)}"
+            )
+    if orden is not None:
+        if orden not in df.columns:
+            raise ValueError(f"el archivo no tiene la columna de orden '{orden}'")
+        df = df.sort_values(orden)
+    gdf = gpd.GeoDataFrame(
+        df,
+        geometry=gpd.points_from_xy(df[x], df[y]),
+        crs=f"EPSG:{epsg}" if epsg else None,
+    )
+    if mostrar:
+        print(f"Cargado '{ruta}': {len(gdf)} puntos | CRS: {gdf.crs}")
+    if len(gdf) == 0:
+        print(f"Aviso: '{ruta}' no tiene filas")
+    return gdf
+
+
+def guardar(
+    gdf: gpd.GeoDataFrame,
+    ruta: str | PathLike[str],
+    gpx_como: str = "track",
+    mostrar: bool = True,
+) -> str | PathLike[str]:
+    """Guarda un GeoDataFrame en disco.
+
+    El formato se deduce de la extensión de `ruta`. Para .gpx/.kml/.kmz
+    reproyecta automáticamente a EPSG:4326 (esos formatos solo aceptan
+    lon/lat) y usa el driver adecuado. Así, convertir es cargar + guardar:
+
+        sig.guardar(sig.cargar("predio.shp"), "predio.kmz")          # SHP -> KMZ
+        sig.guardar(sig.cargar("ruta.shp"), "ruta.gpx")              # SHP -> GPX
+        sig.guardar(sig.cargar("nueva.gpx", capa="tracks"), "x.shp") # GPX -> SHP
+
+    Parámetros
+    ----------
+    gpx_como : "track" | "route"
+        Solo aplica a GPX y a geometrías de línea. El driver GPX decide por
+        tipo de geometría: MultiLineString -> track, LineString -> route. Con
+        "track" (por defecto, que es como trabaja el GPS aquí) se envuelven
+        las líneas como MultiLineString. Los puntos siempre van a waypoints.
+    """
+    if len(gdf) == 0:
+        print(f"Aviso: guardando capa vacía en '{ruta}'")
+    ext = os.path.splitext(str(ruta))[1].lower()
+    carpeta = os.path.dirname(os.path.abspath(ruta))
+    os.makedirs(carpeta, exist_ok=True)
+
+    if ext in _DRIVERS_GEO:
+        gdf = _a_geografico(gdf, ext)
+        ctx = nullcontext()
+        if ext == ".gpx":
+            # extensiones ON para no perder atributos al escribir GPX.
+            ctx = _env("GPX_USE_EXTENSIONS", "YES")
+            # GPX reserva 'fid'; un SHP sin atributos trae esa columna y revienta.
+            gdf = gdf.drop(columns=[c for c in gdf.columns if c.lower() == "fid"])
+            gdf = _poligono_a_borde(gdf)
+            if gpx_como == "track":
+                gdf = _lineas_a_track(gdf)
+        with _traducir_avisos(), ctx:
+            gdf.to_file(ruta, driver=_DRIVERS_GEO[ext])
+    else:
+        with _traducir_avisos():
+            gdf.to_file(ruta)
+
+    if mostrar:
+        print(f"Guardado '{ruta}': {len(gdf)} entidades")
+    return ruta
+
+
+def convertir(
+    entrada: str | PathLike[str],
+    salida: str | PathLike[str],
+    capa: str | None = None,
+    gpx_como: str = "track",
+    mostrar: bool = True,
+) -> str | PathLike[str]:
+    """Convierte un archivo vectorial de un formato a otro (cargar + guardar).
+
+        sig.convertir("ruta.shp", "ruta.gpx")     # SHP -> GPX
+        sig.convertir("nueva.gpx", "nueva.shp")   # GPX -> SHP
+        sig.convertir("predio.shp", "predio.kmz") # SHP -> KMZ
+
+    Si la entrada es GPX y no se indica `capa`, elige automáticamente la que
+    trae datos: un GPX de solo tracks leído "a secas" sale vacío porque la
+    capa por defecto es waypoints. `gpx_como` aplica solo a la salida GPX.
+    """
+    if str(entrada).lower().endswith(".gpx"):
+        gdf = _cargar_gpx_limpio(entrada, capa, mostrar=mostrar)
+    else:
+        gdf = cargar(entrada, capa=capa, mostrar=mostrar)
+    return guardar(gdf, salida, gpx_como=gpx_como, mostrar=mostrar)
+
+
+def _cargar_gpx_limpio(
+    ruta: str | PathLike[str], capa: str | None, mostrar: bool = True
+) -> gpd.GeoDataFrame:
+    """Carga un GPX con la tabla de atributos limpia (estilo Global Mapper).
+
+    Waypoints -> cargar_waypoints; tracks -> cargar_tracks. Si no se indica
+    `capa`, elige la que trae datos. Rutas (routes) u otras capas caen al
+    lector genérico. ponytail: solo waypoints y tracks tienen tabla limpia,
+    que son los que exporta el GPS aquí; agrega routes si algún día hace falta.
+    """
+    if capa is None:
+        capa = _capa_gpx_con_datos(ruta)
+    if capa == "waypoints":
+        return cargar_waypoints(ruta, mostrar=mostrar)
+    if capa == "tracks":
+        return cargar_tracks(ruta, mostrar=mostrar)
+    return cargar(ruta, capa=capa, mostrar=mostrar)
+
+
+def _capa_gpx_con_datos(ruta: str | PathLike[str]) -> str | None:
+    """Primera capa GPX (waypoints > routes > tracks) que trae entidades.
+
+    ponytail: si un GPX mezclara waypoints y tracks devuelve solo el primero;
+    en ese caso pasa `capa=` explícito. No ha pasado con los archivos reales.
+    """
+    for capa in ("waypoints", "routes", "tracks"):
+        try:
+            if len(gpd.read_file(ruta, layer=capa)) > 0:
+                return capa
+        except Exception:
+            pass
+    return None
+
+
+def _a_geografico(gdf: gpd.GeoDataFrame, ext: str) -> gpd.GeoDataFrame:
+    """Reproyecta a EPSG:4326 si hace falta; GPX/KML/KMZ lo exigen."""
+    _exigir_crs(gdf, "capa")
+    if gdf.crs.to_epsg() != 4326:
+        print(f"Reproyectando a EPSG:4326 para exportar a {ext}")
+        return gdf.to_crs(epsg=4326)
+    return gdf
+
+
+def _poligono_a_borde(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """GPX no admite polígonos; exporta su contorno como línea."""
+    if set(gdf.geom_type) & {"Polygon", "MultiPolygon"}:
+        print("GPX no admite polígonos; exporto su contorno como línea")
+        gdf = gdf.copy()
+        gdf["geometry"] = gdf.boundary
+    return gdf
+
+
+def _fmt_hora_es(dt: pd.Timestamp) -> str:
+    """Formatea a 'dd/mm/aaaa hh:mm:ss a. m./p. m.' (formato local español)."""
+    if pd.isna(dt):
+        return ""  # ponytail: track sin tiempo -> campo vacío
+    h12 = ((dt.hour + 11) % 12) + 1
+    suf = "a. m." if dt.hour < 12 else "p. m."
+    return f"{dt.day:02d}/{dt.month:02d}/{dt.year} {h12:02d}:{dt.minute:02d}:{dt.second:02d} {suf}"
+
+
+def cargar_waypoints(
+    ruta: str | PathLike[str], mostrar: bool = True
+) -> gpd.GeoDataFrame:
+    """Carga los waypoints de un GPX en una tabla de atributos limpia.
+
+    Columnas de salida: NAME, LAYER (constante 'Waypoint'), ELEVATION, time
+    (ISO UTC tal cual, p.ej. 2026-02-21T16:09:47Z), sym. Descarta las ~18
+    columnas vacías del esquema fijo de GPX (magvar, hdop, link*, cmt...).
+    """
+    with _traducir_avisos():
+        gdf = gpd.read_file(ruta, layer="waypoints")
+    # ele/time pueden faltar en GPX de otras fuentes; None en vez de reventar
+    ele = gdf.get("ele")
+    t = pd.to_datetime(gdf["time"], utc=True) if "time" in gdf.columns else None
+    salida = gpd.GeoDataFrame(
+        {
+            "NAME": gdf.get("name"),
+            "LAYER": "Waypoint",  # ponytail: etiqueta de capa; no viene en el GPX
+            "ELEVATION": ele.round(6) if ele is not None else None,
+            "time": t.dt.strftime("%Y-%m-%dT%H:%M:%SZ") if t is not None else None,
+            "sym": gdf.get("sym"),
+        },
+        geometry=gdf.geometry,
+        crs=gdf.crs,
+    )
+    if mostrar:
+        print(f"Waypoints '{ruta}': {len(salida)} entidades")
+    return salida
+
+
+def cargar_tracks(
+    ruta: str | PathLike[str], utc_offset: int = -6, mostrar: bool = True
+) -> gpd.GeoDataFrame:
+    """Carga los tracks de un GPX en una tabla de atributos limpia, una linea por tramo.
+
+    Una línea por tramo (<trkseg>). Columnas: NAME, LAYER (constante
+    'Tracklog'), gpxx_DisplayColor (el SHP lo recorta a 'gpxx_Displ'),
+    START_TIME, END_TIME. Los tiempos salen del primer/último punto del tramo,
+    convertidos a hora local (`utc_offset`, por defecto -6 = Jalisco) y con
+    formato español.
+    """
+    with _traducir_avisos():
+        try:
+            meta = gpd.read_file(ruta, layer="tracks")
+        except Exception as e:
+            # GDAL no puede armar la geometria si un <trkseg> trae 1 solo punto
+            if "point array" in str(e):
+                raise ValueError(
+                    f"'{ruta}' tiene un tramo de un solo punto y no se puede leer; "
+                    "borra ese tramo en el GPS o edita el GPX"
+                ) from e
+            raise
+        pts = gpd.read_file(ruta, layer="track_points")
+    pts = pts.sort_values(["track_fid", "track_seg_id", "track_seg_point_id"])
+    t_local = pd.to_datetime(pts["time"], utc=True) + pd.Timedelta(hours=utc_offset)
+    pts = pts.assign(_t=t_local.values)
+
+    filas = []
+    for (fid, _seg), sub in pts.groupby(["track_fid", "track_seg_id"], sort=True):
+        coords = [(p.x, p.y) for p in sub.geometry]
+        if len(coords) < 2:
+            continue  # ponytail: un tramo de 1 punto no es línea, se salta
+        trk = meta.iloc[int(fid)]
+        color = re.search(
+            r"DisplayColor>([^<]+)<", str(trk.get("gpxx_TrackExtension", ""))
+        )
+        filas.append(
+            {
+                "NAME": trk.get("name"),
+                "LAYER": "Tracklog",  # ponytail: etiqueta de capa constante
+                "gpxx_DisplayColor": color.group(1) if color else None,
+                "START_TIME": _fmt_hora_es(sub["_t"].iloc[0]),
+                "END_TIME": _fmt_hora_es(sub["_t"].iloc[-1]),
+                "geometry": LineString(coords),
+            }
+        )
+    salida = gpd.GeoDataFrame(filas, crs=pts.crs)
+    if mostrar:
+        print(f"Tracks '{ruta}': {len(salida)} tramos")
+    return salida
+
+
+def _lineas_a_track(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """Envuelve LineString como MultiLineString para que GPX las escriba como track."""
+
+    def a_multi(g: BaseGeometry | None) -> BaseGeometry | None:
+        return (
+            MultiLineString([g]) if g is not None and g.geom_type == "LineString" else g
+        )
+
+    gdf = gdf.copy()
+    gdf["geometry"] = gdf.geometry.apply(a_multi)
+    return gdf

cfasig/campos.py

@@ -0,0 +1,18 @@
+"""Utilidades para manejar campos (columnas) de atributos."""
+
+import uuid
+
+import geopandas as gpd
+
+
+def campo_seguro(gdf: gpd.GeoDataFrame, campo: str) -> str:
+    """Devuelve un nombre de campo que no choque con los existentes.
+
+    Si `campo` no existe en la capa, lo devuelve tal cual.
+    Si ya existe, devuelve una variante única (campo_ab12) para no pisar datos.
+    """
+    if campo not in gdf.columns:
+        return campo
+    nuevo = f"{campo}_{uuid.uuid4().hex[:4]}"
+    print(f"'{campo}' ya existe, uso '{nuevo}'")
+    return nuevo

cfasig/cli.py

@@ -0,0 +1,107 @@
+"""CLI de cfasig: convierte uno o varios archivos entre formatos SIG.
+
+Un solo comando. ponytail: sin subcomando porque hoy solo convierte. Si algun
+dia agregas mas operaciones (buffer, recortar...), migra a subparsers y el uso
+pasa a `cfasig convertir ARCHIVO TIPO`. El lote es simplemente varios archivos
+(arrastrados a la terminal); sin glob ni flags porque el usuario no tecnico los
+arrastra, no escribe comodines.
+"""
+
+import argparse
+import os
+import sys
+
+TIPOS = ("shp", "gpkg", "geojson", "gpx", "kml", "kmz")
+
+AYUDA = """\
+uso: cfasig ARCHIVO [ARCHIVO ...] TIPO
+
+Convierte uno o varios archivos entre formatos SIG.
+
+argumentos:
+  ARCHIVO   archivo(s) a convertir. Para varios, arrastralos juntos a la
+            terminal (quedan separados por espacios) y luego escribe el TIPO.
+  TIPO      formato de salida: shp, gpkg, geojson, gpx, kml, kmz
+
+ejemplos:
+  cfasig predio.shp kmz              -> crea predio.kmz
+  cfasig ruta.gpx shp                -> crea ruta.shp
+  cfasig a.shp b.shp c.shp kmz       -> crea a.kmz, b.kmz, c.kmz
+
+opciones avanzadas (normalmente no hacen falta):
+  --capa NOMBRE             capa a leer si el archivo trae varias (GPX/GeoPackage)
+  --gpx-como {track,route}  como escribir lineas al exportar a GPX (def: track)
+  -h, --ayuda               muestra esta ayuda
+"""
+
+
+class _Parser(argparse.ArgumentParser):
+    """Error breve y en español en vez del volcado tecnico de argparse."""
+
+    def error(self, message: str) -> None:
+        sys.stderr.write(
+            f"Error: {message}\nEscribe 'cfasig ayuda' para ver como se usa.\n"
+        )
+        raise SystemExit(2)
+
+
+def _build() -> _Parser:
+    p = _Parser(add_help=False)
+    p.add_argument(
+        "archivos", nargs="+"
+    )  # uno o varios; argparse deja el ultimo para tipo
+    p.add_argument("tipo")
+    p.add_argument("--capa")
+    p.add_argument(
+        "--gpx-como", dest="gpx_como", choices=("track", "route"), default="track"
+    )
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+
+    # Sin argumentos o pidiendo ayuda: muestra la ayuda y sale.
+    if not argv or argv[0] in ("ayuda", "help", "-h", "--ayuda", "--help"):
+        print(AYUDA)
+        return 0
+
+    args = _build().parse_args(argv)
+
+    tipo = args.tipo.lower().lstrip(".")
+    if tipo not in TIPOS:
+        print(f"Error: tipo '{args.tipo}' no valido. Usa uno de: {', '.join(TIPOS)}.")
+        return 2
+
+    from . import convertir  # import perezoso: la ayuda no carga geopandas
+
+    ok = fallo = 0
+    for archivo in args.archivos:
+        if not os.path.exists(archivo):
+            print(f"Error: no existe el archivo '{archivo}'.")
+            fallo += 1
+            continue
+        # Salida autonombrada: misma carpeta y nombre, extension nueva.
+        salida = os.path.splitext(archivo)[0] + "." + tipo
+        if os.path.abspath(salida) == os.path.abspath(archivo):
+            print(f"Aviso: '{archivo}' ya es {tipo}, se salta.")
+            continue
+        if os.path.exists(salida):
+            resp = input(f"'{salida}' ya existe. Sobrescribir? [s/N]: ").strip().lower()
+            if resp not in ("s", "si", "sí"):
+                print("Saltado.")
+                continue
+        try:
+            convertir(archivo, salida, capa=args.capa, gpx_como=args.gpx_como)
+            ok += 1
+        except Exception as e:
+            print(f"Error convirtiendo '{archivo}': {e}")
+            fallo += 1
+
+    if len(args.archivos) > 1:
+        print(f"\nListo: {ok} convertidos, {fallo} con error.")
+    return 1 if fallo else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())