g360-cli 1.6.1 → 1.7.1

package/src/assets/templates/python-flet/src/core/ingestion.py

@@ -0,0 +1,480 @@
+import re
+import unicodedata
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+_KEYWORDS_ID = [
+    "sku", "codigo", "cod_art", "articulo", "id_cliente", "doc_cliente",
+    "id_vendedor", "id_linea", "id_grupo", "id_tipo", "id_familia",
+    "id_articulo", "cod_sucursal", "serie_doc", "nro_doc", "id_guia",
+    "id_pedido", "id_localidad_ubigeo",
+]
+_KEYWORDS_TEXTO = [
+    "linea", "nombre", "razon_social", "descripcion", "departamento",
+    "provincia", "distrito", "vendedor", "condicion", "division", "estado",
+    "canal", "moneda", "referencia", "grupo", "tipo", "familia", "sucursal",
+]
+_KEYWORDS_DINERO = [
+    "neto", "bruto", "venta", "valor", "total", "soles", "dolares",
+]
+_KEYWORDS_CANTIDAD = [
+    "cantidad",
+]
+_KEYWORDS_FECHA = ["fecha", "fec_", "venc"]
+
+_MAPA_TPO_DOC = {
+    "NCR": "NOTA DE CREDITO",
+    "NDB": "NOTA DE DEBITO",
+    "BDI": "BIEN / BOLETA",
+    "FAC": "FACTURA",
+    "NV":  "NOTA DE VENTA",
+    "GV":  "GUIA DE VENTA",
+    "FC":  "FACTURA CREDITO",
+    "NC":  "NOTA DE CREDITO",
+    "ND":  "NOTA DE DEBITO",
+    "BO":  "BOLETA",
+}
+
+_MAPA_MESES = {
+    "ENERO": 1, "FEBRERO": 2, "MARZO": 3, "ABRIL": 4, "MAYO": 5, "JUNIO": 6,
+    "JULIO": 7, "AGOSTO": 8, "SETIEMBRE": 9, "OCTUBRE": 10, "NOVIEMBRE": 11, "DICIEMBRE": 12,
+    "ENE": 1, "FEB": 2, "MAR": 3, "ABR": 4, "MAY": 5, "JUN": 6,
+    "JUL": 7, "AGO": 8, "SET": 9, "OCT": 10, "NOV": 11, "DIC": 12,
+    "ENERO": 1, "FEBRERO": 2, "MARZO": 3, "ABRIL": 4, "MAYO": 5, "JUNIO": 6,
+    "JULIO": 7, "AGOSTO": 8, "SEPTIEMBRE": 9, "OCTUBRE": 10, "NOVIEMBRE": 11, "DICIEMBRE": 12,
+}
+
+_PATRON_DIRECCION = re.compile(
+    r'^(JR\.?\s|AV\.?\s|AVENIDA\s|CALLE\s|PASAJE\s|PSJE\.?\s|'
+    r'CARRETERA\s|CARRE\.?\s|MZA\.?\s|LOTE\s|URB\.?\s|'
+    r'FUNDO\s|SECTOR\s|PARQUE\s|PLAZA\s|ALAMEDA\s|JR|AV)\b',
+    re.IGNORECASE,
+)
+
+_PATRON_REFERENCIA = re.compile(
+    r'^([A-Za-z]+)(\d+)[/.-]?(\d{1,4})?[/.-]?(\d+)?$'
+)
+
+
+def _limpiar_cabecera(col: str) -> str:
+    if not isinstance(col, str):
+        col = str(col)
+    col = col.strip().lower()
+    col = "".join(
+        c for c in unicodedata.normalize("NFD", col)
+        if unicodedata.category(c) != "Mn"
+    )
+    col = col.replace(" ", "_").replace(".", "").replace("/", "_")
+    col = re.sub(r"_+", "_", col)
+    col = col.strip("_")
+    return col
+
+
+def _coincide_keywords(nombre_col: str, keywords: list[str]) -> bool:
+    return any(kw in nombre_col for kw in keywords)
+
+
+def _detectar_formato_numero(series: pd.Series) -> str:
+    muestras = series.dropna().astype(str).head(50)
+    coma_decimal = muestras.str.contains(r',\d{2}$', regex=True).sum()
+    punto_decimal = muestras.str.contains(r'\.\d{2}$', regex=True).sum()
+    if coma_decimal > punto_decimal:
+        return "spring"
+    if punto_decimal > coma_decimal:
+        return "sap"
+    return "simple"
+
+
+def _normalizar_monetario(series: pd.Series) -> pd.Series:
+    if series.dtype != object:
+        return pd.to_numeric(series, errors="coerce").fillna(0.0)
+    fmt = _detectar_formato_numero(series)
+    if fmt == "spring":
+        series = series.astype(str).str.replace(".", "", regex=False)
+        series = series.str.replace(",", ".", regex=False)
+    elif fmt == "sap":
+        series = series.astype(str).str.replace(",", "", regex=False)
+    series = (
+        series.astype(str)
+        .str.replace("S/.", "", regex=False)
+        .str.replace("S//.", "", regex=False)
+        .str.replace("$", "", regex=False)
+        .str.replace("US$", "", regex=False)
+        .str.strip()
+    )
+    return pd.to_numeric(series, errors="coerce").fillna(0.0)
+
+
+def _parsear_referencia(series: pd.Series) -> pd.DataFrame:
+    tipos: list[str | None] = []
+    series_doc: list[str | None] = []
+    periodos: list[str | None] = []
+    numeros: list[str | None] = []
+    for val in series:
+        if pd.isna(val):
+            tipos.append(None)
+            series_doc.append(None)
+            periodos.append(None)
+            numeros.append(None)
+            continue
+        m = _PATRON_REFERENCIA.match(str(val).strip())
+        if m:
+            tipos.append(m.group(1).upper())
+            series_doc.append(m.group(2))
+            periodos.append(m.group(3))
+            numeros.append(m.group(4))
+        else:
+            tipos.append(None)
+            series_doc.append(None)
+            periodos.append(None)
+            numeros.append(None)
+    return pd.DataFrame({
+        "ref_tipo_doc": tipos,
+        "ref_serie": series_doc,
+        "ref_periodo": periodos,
+        "ref_nro": numeros,
+    })
+
+
+def _extraer_nombre_desde_direccion(
+    direccion: str,
+    lugares: list[str],
+) -> str | None:
+    tokens = re.split(r'[,\s]+', direccion.strip())
+    tokens = [t for t in tokens if t]
+    for t in reversed(tokens):
+        t_clean = t.strip(".").upper()
+        if t_clean in lugares:
+            return t_clean.capitalize()
+    if tokens:
+        return tokens[-1].capitalize()
+    return None
+
+
+def _es_direccion(val: object) -> bool:
+    if pd.isna(val):
+        return False
+    s = str(val).strip()
+    if not s:
+        return False
+    return bool(_PATRON_DIRECCION.match(s)) or "N°" in s or "NRO" in s.upper()
+
+
+def _parsear_sucursal_fila(
+    val: object, lugares: list[str]
+) -> tuple[str | None, str | None]:
+    if pd.isna(val):
+        return None, None
+    s = str(val).strip()
+    if not s:
+        return None, None
+    if _es_direccion(s):
+        nombre = _extraer_nombre_desde_direccion(s, lugares)
+        return nombre, s
+    return s, None
+
+
+def _parsear_sucursal(
+    df: pd.DataFrame,
+    col_nom: str = "nom_sucursal",
+    col_depto: str = "nom_departamento",
+    col_prov: str = "nom_provincia",
+    col_dist: str = "nom_distrito",
+) -> pd.DataFrame:
+    if col_nom not in df.columns:
+        df["sucursal_nombre"] = None
+        df["sucursal_direccion"] = None
+        return df
+
+    lugares: list[str] = []
+    for c in [col_depto, col_prov, col_dist]:
+        if c in df.columns:
+            lugares.extend(
+                str(v).strip().upper()
+                for v in df[c].dropna().unique()
+                if str(v).strip()
+            )
+    lugares = list(set(lugares))
+
+    resultados = df[col_nom].apply(lambda v: _parsear_sucursal_fila(v, lugares))
+    df["sucursal_nombre"] = resultados.apply(lambda x: x[0])
+    df["sucursal_direccion"] = resultados.apply(lambda x: x[1])
+
+    return df
+
+
+def _clasificar_doc_cliente(val: object) -> tuple[str, str]:
+    limpio = re.sub(r"\D", "", str(val))
+    if len(limpio) == 11:
+        return limpio, "RUC"
+    elif len(limpio) == 8:
+        return limpio.zfill(8), "DNI"
+    elif len(limpio) > 0:
+        return limpio, "OTRO"
+    return "", "SIN_DOC"
+
+
+def _parsear_mes(val: object) -> tuple[int | None, str | None]:
+    if pd.isna(val):
+        return None, None
+    s = str(val).strip().upper()
+    m = re.match(r'^(\d{1,2})[-/](\w+)$', s)
+    if m:
+        num = int(m.group(1))
+        nombre = m.group(2).capitalize()
+        return num, nombre
+    if s.isdigit():
+        return int(s), None
+    if s in _MAPA_MESES:
+        return _MAPA_MESES[s], s.capitalize()
+    return None, None
+
+
+def _clasificar_transaccion(row: dict) -> str:
+    cant = row.get("cantidad", 0)
+    cant_fae = row.get("cantidad_fae", 0)
+    if cant > 0 and cant_fae == 0:
+        return "venta"
+    if cant < 0 and cant_fae == 0:
+        return "devolucion"
+    if cant == 0 and cant_fae != 0:
+        return "regularizacion"
+    if cant != 0 and cant_fae != 0:
+        return "mixto"
+    return "indefinido"
+
+
+def estabilizar_excel_crudo(ruta_archivo: str | Path) -> tuple[pd.DataFrame, dict]:
+    ruta = Path(ruta_archivo)
+    if not ruta.exists():
+        raise FileNotFoundError(f"Archivo no encontrado: {ruta}")
+
+    sufijo = ruta.suffix.lower()
+    if sufijo == ".xls":
+        engine = "xlrd"
+    elif sufijo in (".xlsx", ".xlsm"):
+        engine = "openpyxl"
+    else:
+        engine = None
+
+    transformaciones: list[str] = []
+    alertas: list[str] = []
+
+    df = pd.read_excel(ruta, engine=engine)
+    transformaciones.append(f"lectura: {len(df)} filas, {len(df.columns)} columnas")
+
+    cols_originales = list(df.columns)
+
+    # ── 1. Normalizar cabeceras ──
+    df.columns = [_limpiar_cabecera(c) for c in df.columns]
+    transformaciones.append("cabeceras: normalizadas (lower, sin tildes, snake_case)")
+
+    # ── 2. Resolver duplicados en cabeceras ──
+    duplicados = [c for c in df.columns.tolist() if df.columns.tolist().count(c) > 1]
+    if duplicados:
+        vistos: dict[str, int] = {}
+        nuevas: list[str] = []
+        for c in df.columns:
+            if c in vistos:
+                vistos[c] += 1
+                nuevas.append(f"{c}_{vistos[c]}")
+            else:
+                vistos[c] = 0
+                nuevas.append(c)
+        df.columns = nuevas
+        transformaciones.append(f"cabeceras: {len(set(duplicados))} columna(s) duplicada(s) renombrada(s)")
+
+    # ── 3. Eliminar filas totalmente vacías ──
+    df = df.dropna(how="all").copy()
+    transformaciones.append(f"filas: {len(df)} tras eliminar vacias totales")
+
+    # ── 4. Parsear REFERENCIA ──
+    if "referencia" in df.columns:
+        ref_parsed = _parsear_referencia(df["referencia"])
+        for c in ref_parsed.columns:
+            df[c] = ref_parsed[c].values
+        transformaciones.append("referencia: parseada en ref_tipo_doc, ref_serie, ref_periodo, ref_nro")
+
+    # ── 5. Parsear NOM_SUCURSAL ──
+    df = _parsear_sucursal(df)
+    if "sucursal_nombre" in df.columns and "sucursal_direccion" in df.columns:
+        transformaciones.append("sucursal: separada nombre/direccion")
+
+    if ("nom_sucursal" in df.columns and "sucursal_nombre" in df.columns and
+            df["sucursal_nombre"].isna().any()):
+        alertas.append("sucursal: algunos nombres no pudieron determinarse")
+
+    # ── 6. Normalizar MES ──
+    if "mes" in df.columns:
+        parsed = df["mes"].apply(_parsear_mes)
+        df["mes_num"] = parsed.apply(lambda x: x[0])
+        df["mes_nombre"] = parsed.apply(lambda x: x[1])
+        transformaciones.append("mes: separado en mes_num y mes_nombre")
+
+    # ── 7. Mapear TPO_DOC ──
+    if "tpo_doc" in df.columns:
+        df["tipo_doc_nombre"] = df["tpo_doc"].map(_MAPA_TPO_DOC)
+        codigos_no_mapeados = df["tpo_doc"].dropna().unique()
+        no_map = [c for c in codigos_no_mapeados if c not in _MAPA_TPO_DOC]
+        if no_map:
+            for c in no_map:
+                limpio = re.sub(r'\d', '', str(c)).strip()
+                _MAPA_TPO_DOC[c] = limpio if limpio else c
+            df["tipo_doc_nombre"] = df["tpo_doc"].map(_MAPA_TPO_DOC).fillna("OTRO")
+            alertas.append(f"tpo_doc: codigos sin mapeo: {', '.join(sorted(str(c) for c in no_map))}")
+        transformaciones.append("tpo_doc: mapeado a nombre legible")
+
+    # ── 8. Columnas ID ──
+    for col in df.columns:
+        if _coincide_keywords(col, _KEYWORDS_ID):
+            was_numeric = pd.api.types.is_numeric_dtype(df[col])
+            df[col] = (
+                df[col].astype(str)
+                .str.replace(r"\.0$", "", regex=True)
+                .str.strip()
+            )
+            if was_numeric:
+                vals_clean = df[col].replace("nan", np.nan).dropna()
+                if len(vals_clean) > 0:
+                    max_len = int(vals_clean.str.len().max())
+                    has_shorter = (vals_clean.str.len() < max_len).any()
+                    if has_shorter and max_len > 1:
+                        df[col] = df[col].str.zfill(max_len)
+                        transformaciones.append(f"{col}: leading zeros restaurados (zfill={max_len})")
+            df[col] = df[col].replace("nan", np.nan)
+
+    # ── 9. Normalizar DOC_CLIENTE (despues de ID para tener strings limpios) ──
+    for col in [c for c in df.columns if _coincide_keywords(c, ["doc_cliente"])]:
+        parsed = df[col].apply(_clasificar_doc_cliente)
+        tipo_col = f"tipo_{col}"
+        clean_col = f"{col}_clean"
+        df[clean_col] = parsed.apply(lambda x: x[0])
+        df[tipo_col] = parsed.apply(lambda x: x[1])
+        ruc_count = (df[tipo_col] == "RUC").sum()
+        dni_count = (df[tipo_col] == "DNI").sum()
+        transformaciones.append(
+            f"{col}: normalizado ({ruc_count} RUC, {dni_count} DNI, "
+            f"{(~df[tipo_col].isin(['RUC','DNI'])).sum()} otros)"
+        )
+
+    # ── 10. Columnas TEXTO ──
+    for col in df.columns:
+        if _coincide_keywords(col, _KEYWORDS_TEXTO):
+            df[col] = df[col].astype(str).str.strip()
+            df[col] = df[col].replace("nan", np.nan)
+            df[col] = df[col].apply(
+                lambda v: unicodedata.normalize("NFC", v) if isinstance(v, str) else v
+            )
+
+    # ── 11. Columnas DINERO ──
+    for col in df.columns:
+        if _coincide_keywords(col, _KEYWORDS_DINERO):
+            antes = df[col].dtype
+            df[col] = _normalizar_monetario(df[col])
+            if str(antes) != str(df[col].dtype):
+                transformaciones.append(f"{col}: monetario normalizado a float64")
+            nulos = (df[col] == 0.0).sum()
+            if nulos > 0:
+                transformaciones.append(f"{col}: {nulos} valor(es) zero por NaN original")
+
+    # ── 12. Columnas CANTIDAD ──
+    cols_cantidad = [c for c in df.columns if _coincide_keywords(c, _KEYWORDS_CANTIDAD)]
+    for col in cols_cantidad:
+        df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0.0)
+        transformaciones.append(f"{col}: forzado a float64, NaN → 0.0")
+
+    # ── 13. cantidad + cantidad_fae → cantidad_total, tipo_transaccion ──
+    if "cantidad" in df.columns:
+        if "cantidad_fae" in df.columns:
+            df["cantidad_total"] = df["cantidad"] + df["cantidad_fae"]
+            transformaciones.append("cantidad_total: suma de cantidad + cantidad_fae")
+        else:
+            df["cantidad_total"] = df["cantidad"]
+        df["tipo_transaccion"] = df.apply(_clasificar_transaccion, axis=1)
+        t_counts = df["tipo_transaccion"].value_counts().to_dict()
+        transformaciones.append(f"tipo_transaccion: {t_counts}")
+
+    # ── 14. Columnas FECHA ──
+    for col in df.columns:
+        if _coincide_keywords(col, _KEYWORDS_FECHA) and col != "fec_":
+            if pd.api.types.is_datetime64_any_dtype(df[col]):
+                continue
+            antes_nulos = df[col].isna().sum()
+            df[col] = pd.to_datetime(df[col], errors="coerce", dayfirst=True)
+            ahora_nulos = df[col].isna().sum()
+            if ahora_nulos > antes_nulos:
+                alertas.append(f"{col}: {ahora_nulos - antes_nulos} fecha(s) invalida(s) → NaT")
+            df[col] = df[col].fillna(pd.Timestamp.now().normalize())
+            transformaciones.append(f"{col}: datetime + NaT → today")
+
+    # ── 15. Validar MONEDA ──
+    if "moneda" in df.columns:
+        monedas = df["moneda"].dropna().unique()
+        monedas_str = [str(m).strip().upper() for m in monedas]
+        validas = {"SOL", "S/.", "PEN", "S/."}
+        if not all(m in validas for m in monedas_str):
+            raras = [m for m in monedas_str if m not in validas]
+            alertas.append(f"moneda: valores no esperados: {raras}")
+        transformaciones.append(f"moneda: todas en soles ({', '.join(monedas_str)})")
+        df["moneda_cod"] = "PEN"
+
+    # ── 16. Purga filas basura ──
+    for col in df.columns:
+        if df[col].dtype == object:
+            muestra = df[col].dropna().head(20).astype(str).tolist()
+            if any(
+                isinstance(v, str) and v.lower().strip() in ("total", "general", "totales", "acumulado")
+                for v in muestra
+            ):
+                mascara = df[col].astype(str).str.lower().str.strip().isin(
+                    ["total", "general", "totales", "acumulado"]
+                )
+                n = mascara.sum()
+                df = df[~mascara].copy()
+                if n:
+                    transformaciones.append(f"basura: {n} fila(s) 'total/general' eliminadas")
+
+    cols_id_presentes = [c for c in df.columns if _coincide_keywords(c, _KEYWORDS_ID)]
+    if cols_id_presentes:
+        mascara_ids_nulos = df[cols_id_presentes].isna().all(axis=1) | (
+            df[cols_id_presentes].astype(str).replace("nan", "") == ""
+        ).all(axis=1)
+        mascara_dinero_cero = True
+        cols_dinero_presentes = [
+            c for c in df.columns if _coincide_keywords(c, _KEYWORDS_DINERO)
+        ]
+        if cols_dinero_presentes:
+            mascara_dinero_cero = (df[cols_dinero_presentes] == 0.0).all(axis=1)
+        cols_cant_presentes = [c for c in df.columns if _coincide_keywords(c, _KEYWORDS_CANTIDAD)]
+        if cols_cant_presentes:
+            mascara_dinero_cero = mascara_dinero_cero & (df[cols_cant_presentes] == 0.0).all(axis=1)
+        mascara_fila_total = mascara_ids_nulos & (
+            ~mascara_dinero_cero if isinstance(mascara_dinero_cero, pd.Series) else True
+        )
+        n_purge = mascara_fila_total.sum()
+        df = df[~mascara_fila_total].copy()
+        if n_purge:
+            transformaciones.append(f"basura: {n_purge} fila(s) sin ID y con dinero eliminadas")
+
+    df = df.reset_index(drop=True)
+
+    metadata = {
+        "archivo": str(ruta),
+        "filas_originales": len(df) + sum(
+            1 for t in transformaciones if "eliminadas" in t
+        ),
+        "filas_estabilizadas": len(df),
+        "columnas_originales": cols_originales,
+        "columnas_finales": list(df.columns),
+        "columnas_nuevas": [
+            c for c in df.columns if c not in [_limpiar_cabecera(x) for x in cols_originales]
+        ],
+        "transformaciones": transformaciones,
+        "alertas": alertas,
+        "moneda": "PEN",
+    }
+
+    return df, metadata

package/src/assets/templates/python-flet/src/main.py

@@ -2,6 +2,7 @@ import sys
 from pathlib import Path
 import flet as ft
 from core.g360_theme import G360Theme
+from ui.ingestion_panel import IngestionPanel
 
 BASE_DIR = Path(__file__).resolve().parent.parent
 if str(BASE_DIR) not in sys.path:
@@ -12,9 +13,15 @@ class G360App:
     def __init__(self, page: ft.Page):
         self.page = page
         self.theme = G360Theme()
+        self.df = None
+        self.metadata = None
         self._setup_page()
         self._build_ui()
 
+    def _on_data_loaded(self, df, metadata):
+        self.df = df
+        self.metadata = metadata
+
     def _setup_page(self):
         self.page.title = self.theme.build_name()
         self.page.theme_mode = ft.ThemeMode.DARK
@@ -27,6 +34,10 @@ class G360App:
 
     def _build_ui(self):
         self.loading = self.theme.loading_overlay()
+        self.ingestion_panel = IngestionPanel(
+            self.theme, on_data_loaded=self._on_data_loaded
+        )
+        self.page.overlay.append(self.ingestion_panel.file_picker)
         self.page.add(
             ft.Stack(
                 controls=[
@@ -88,21 +99,29 @@ class G360App:
         return ft.Column(
             controls=[
                 self.theme.styled_text(
-                    "Bienvenido a G360 Desktop",
+                    "Ingesta de Datos - Escudo de Saneamiento",
                     size=24,
                     weight=ft.FontWeight.BOLD,
                 ),
+                ft.Container(height=8),
+                self.theme.styled_text(
+                    "Carga tu archivo .xls/.xlsx del ERP. Los datos se normalizan automaticamente.",
+                    size=14,
+                    color=self.theme.muted,
+                ),
+                ft.Container(height=16),
+                self.ingestion_panel,
                 ft.Container(height=20),
                 ft.Row(
                     controls=[
                         self._build_card(
-                            "Usuarios", "Gestión de usuarios", ft.icons.PEOPLE
+                            "Usuarios", "Gestion de usuarios", ft.icons.PEOPLE
                         ),
                         self._build_card(
                             "Reportes", "Ver reportes", ft.icons.ANALYTICS
                         ),
                         self._build_card(
-                            "Configuración", "Ajustes del sistema", ft.icons.SETTINGS
+                            "Configuracion", "Ajustes del sistema", ft.icons.SETTINGS
                         ),
                     ],
                     spacing=20,

package/src/assets/templates/python-flet/src/test_ingestion.py

@@ -0,0 +1,121 @@
+import unittest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+import numpy as np
+import pandas as pd
+
+from core.ingestion import estabilizar_excel_crudo, _limpiar_cabecera, _coincide_keywords
+
+
+class TestLimpiarCabecera(unittest.TestCase):
+    def test_espacios_y_mayusculas(self):
+        self.assertEqual(_limpiar_cabecera("  NOM_CLIENTE  "), "nom_cliente")
+
+    def test_tildes(self):
+        self.assertEqual(_limpiar_cabecera("División"), "division")
+        self.assertEqual(_limpiar_cabecera("Línea"), "linea")
+
+    def test_espacios_intermedios(self):
+        self.assertEqual(_limpiar_cabecera("CANAL DE DISTRIBUCION"), "canal_de_distribucion")
+
+    def test_puntos(self):
+        self.assertEqual(_limpiar_cabecera("DOC_CLIENTE.1"), "doc_cliente1")
+
+    def test_barras(self):
+        self.assertEqual(_limpiar_cabecera("S/PRECIO"), "s_precio")
+
+    def test_guiones_dobles(self):
+        self.assertEqual(_limpiar_cabecera("NOM  CLIENTE"), "nom_cliente")
+
+    def test_no_string(self):
+        self.assertEqual(_limpiar_cabecera(42), "42")
+
+
+class TestCoincideKeywords(unittest.TestCase):
+    def test_id(self):
+        self.assertTrue(_coincide_keywords("id_cliente", ["id_cliente", "doc"]))
+
+    def test_parcial(self):
+        self.assertTrue(_coincide_keywords("soles", ["soles", "dolares"]))
+
+    def test_no_coincide(self):
+        self.assertFalse(_coincide_keywords("nombre", ["soles", "dolares"]))
+
+
+_SAMPLE_DF = pd.DataFrame({
+    "ANHO": [2026.0, 2026.0, np.nan],
+    "ID_ARTICULO": ["11030", "78456", np.nan],
+    "NOM_CLIENTE": ["  CLIENTE A  ", "CLIENTE B", np.nan],
+    "SOLES": [1172.10, "S/.2,500.50", np.nan],
+    "FECHA_ORIG": ["24/06/2026", "20/06/2026", np.nan],
+    "ID_LINEA": ["0111", "0178", np.nan],
+})
+
+
+def _patched_ingestion(df_data, ruta="fake.xls"):
+    with patch("core.ingestion.pd.read_excel", return_value=df_data.copy()), \
+         patch.object(Path, "exists", return_value=True):
+        return estabilizar_excel_crudo(ruta)
+
+
+class TestEstabilizarExcelCrudo(unittest.TestCase):
+
+    def test_normalizacion_completa(self):
+        df, meta = _patched_ingestion(_SAMPLE_DF)
+
+        self.assertIn("anho", df.columns)
+        self.assertIn("id_articulo", df.columns)
+        self.assertIn("nom_cliente", df.columns)
+        self.assertIn("soles", df.columns)
+        self.assertIn("fecha_orig", df.columns)
+        self.assertIn("id_linea", df.columns)
+        self.assertEqual(df["id_linea"].iloc[0], "0111")
+        self.assertEqual(df["id_linea"].iloc[1], "0178")
+
+    def test_ids_como_texto_sin_ceros_perdidos(self):
+        df, _ = _patched_ingestion(_SAMPLE_DF)
+        self.assertEqual(df["id_articulo"].iloc[0], "11030")
+        self.assertEqual(df["id_articulo"].iloc[1], "78456")
+
+    def test_dinero_limpio(self):
+        df, _ = _patched_ingestion(_SAMPLE_DF)
+        self.assertAlmostEqual(df["soles"].iloc[0], 1172.10, places=2)
+        self.assertAlmostEqual(df["soles"].iloc[1], 2500.50, places=2)
+
+    def test_fechas_como_datetime(self):
+        df, _ = _patched_ingestion(_SAMPLE_DF)
+        self.assertTrue(pd.api.types.is_datetime64_any_dtype(df["fecha_orig"]))
+
+    def test_filas_vacias_eliminadas(self):
+        df, _ = _patched_ingestion(_SAMPLE_DF)
+        self.assertEqual(len(df), 2)
+
+    def test_metadata_creada(self):
+        df, meta = _patched_ingestion(_SAMPLE_DF)
+        self.assertIn("filas_estabilizadas", meta)
+        self.assertIn("columnas_finales", meta)
+        self.assertEqual(meta["filas_estabilizadas"], 2)
+
+    def test_soles_sin_nan(self):
+        df, _ = _patched_ingestion(_SAMPLE_DF)
+        self.assertFalse(df["soles"].isna().any())
+
+    def test_archivo_no_existe(self):
+        with self.assertRaises(FileNotFoundError):
+            estabilizar_excel_crudo("no_existe_archivo_falso_999.xls")
+
+
+class TestColumnasDuplicadas(unittest.TestCase):
+    def test_duplicados_se_sufijan(self):
+        df_dup = pd.DataFrame({
+            "DOC_CLIENTE": [1.0, 2.0],
+            "DOC_CLIENTE.1": [1.0, 2.0],
+            "SOLES": [100.0, 200.0],
+        })
+        df, meta = _patched_ingestion(df_dup)
+        cols = list(df.columns)
+        self.assertEqual(len(set(cols)), len(cols), f"Columnas duplicadas: {cols}")
+
+
+if __name__ == "__main__":
+    unittest.main()