g360-cli 1.7.1 → 1.9.0

package/py/src/g360_core/ingestion.py

@@ -1,480 +0,0 @@
-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