Bot 2: Script funcional para el procesamiento y filtrado de los archivos descargados

This commit is contained in:
2026-09-16 14:24:35 -03:00
parent 221e236d73
commit 5c422fe3ef
6 changed files with 175 additions and 25 deletions

View File

@@ -20,6 +20,11 @@ MARKER_SUFFIX = ".procesado"
# TODO: completar con la lista real (por ahora solo los dos ejemplos dados). # TODO: completar con la lista real (por ahora solo los dos ejemplos dados).
PREFIJOS_PERSONAS_JURIDICAS = ["8000", "801"] PREFIJOS_PERSONAS_JURIDICAS = ["8000", "801"]
# Longitud exacta que debe tener el RUC (sin el dv) para considerarse persona jurídica,
# ej. "80119080". Si no cumple, el registro se trata como persona física aunque el
# prefijo coincida.
LONGITUD_RUC_JURIDICA = 8
# Tabla y columna donde ya están cargadas las personas existentes # Tabla y columna donde ya están cargadas las personas existentes
TABLA_PERSONAS = os.getenv("TABLA_PERSONAS", "personas") TABLA_PERSONAS = os.getenv("TABLA_PERSONAS", "personas")
COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc") COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc")
@@ -29,3 +34,6 @@ CSV_CHUNK_SIZE = 80000
# Carpeta donde se escriben los CSV con los RUC faltantes # Carpeta donde se escriben los CSV con los RUC faltantes
OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida") OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida")
# Carpeta donde se escribe el .log de cada corrida (por defecto, la misma que OUTPUT_DIR)
LOG_DIR = os.getenv("LOG_DIR", OUTPUT_DIR)

View File

@@ -1,4 +1,5 @@
import logging import logging
import re
import pymysql import pymysql
@@ -6,6 +7,19 @@ from config import DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSON
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
_RUC_BASE_RE = re.compile(r"^\d+")
def _normalizar_ruc(ruc):
"""
Para las personas físicas, el ruc en la BD viene casi siempre como número puro
(sin el dv pegado). Para poder comparar contra el ruc plano que trae el DNIT,
nos quedamos solo con el prefijo numérico inicial.
Devuelve None para filas basura que no arrancan con un dígito.
"""
match = _RUC_BASE_RE.match(str(ruc).strip())
return match.group() if match else None
def get_connection(): def get_connection():
return pymysql.connect( return pymysql.connect(
@@ -21,8 +35,9 @@ def get_connection():
def fetch_rucs_existentes(conn): def fetch_rucs_existentes(conn):
""" """
Trae todos los RUC ya cargados en la tabla personas y los devuelve Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados
como set (lookup O(1) para comparar contra los parseados del DNIT). (para jurídicas eso es casi siempre "ruc-dv" literal), como set para comparar
contra la clave "ruc-dv" armada con los datos del DNIT.
""" """
query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}" query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}"
existentes = set() existentes = set()
@@ -32,3 +47,20 @@ def fetch_rucs_existentes(conn):
existentes.add(str(ruc).strip()) existentes.add(str(ruc).strip())
logger.info("RUC existentes en %s: %d", TABLA_PERSONAS, len(existentes)) logger.info("RUC existentes en %s: %d", TABLA_PERSONAS, len(existentes))
return existentes return existentes
def fetch_passwords_fisicas(conn):
"""
Trae ruc y password de las personas físicas (tipo_persona = 'F') ya cargadas,
como dict {ruc: password_actual} para comparar contra el dv del DNIT.
"""
query = f"SELECT {COLUMNA_RUC}, password FROM {TABLA_PERSONAS} WHERE tipo_persona = 'F'"
passwords = {}
with conn.cursor() as cur:
cur.execute(query)
for ruc, password in cur.fetchall():
ruc_base = _normalizar_ruc(ruc)
if ruc_base:
passwords[ruc_base] = password
logger.info("Personas físicas cargadas en %s: %d", TABLA_PERSONAS, len(passwords))
return passwords

View File

@@ -6,10 +6,10 @@ from config import OUTPUT_DIR, CSV_CHUNK_SIZE
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado", "archivo_origen"] ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado"]
def exportar_csv(registros, prefijo_nombre="rucs_faltantes"): def exportar_csv(registros, prefijo_nombre="rucs_faltantes", encabezado=ENCABEZADO):
""" """
Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno. Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno.
Devuelve la lista de rutas generadas. Devuelve la lista de rutas generadas.
@@ -28,7 +28,7 @@ def exportar_csv(registros, prefijo_nombre="rucs_faltantes"):
ruta = os.path.join(OUTPUT_DIR, f"{prefijo_nombre}_part{i + 1}.csv") ruta = os.path.join(OUTPUT_DIR, f"{prefijo_nombre}_part{i + 1}.csv")
with open(ruta, "w", newline="", encoding="utf-8") as f: with open(ruta, "w", newline="", encoding="utf-8") as f:
writer = csv.writer(f) writer = csv.writer(f)
writer.writerow(ENCABEZADO) writer.writerow(encabezado)
writer.writerows(bloque) writer.writerows(bloque)
rutas.append(ruta) rutas.append(ruta)

View File

@@ -1,31 +1,113 @@
import logging import logging
from config import PREFIJOS_PERSONAS_JURIDICAS from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
def _es_juridica(ruc):
"""
Jurídica solo si el prefijo coincide Y el RUC (sin el dv) tiene la longitud
esperada, ej. "80119080" (8 caracteres). Si el prefijo coincide pero la longitud
no, se considera persona física.
"""
return (
len(ruc) == LONGITUD_RUC_JURIDICA
and any(ruc.startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS)
)
def filtrar_juridicas(registros): def filtrar_juridicas(registros):
""" """
registros: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen) registros: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen)
Devuelve solo los que corresponden a persona jurídica según el prefijo del RUC. Devuelve solo los que corresponden a persona jurídica según el prefijo y la
longitud del RUC.
""" """
filtrados = [ filtrados = [r for r in registros if _es_juridica(r[0])]
r for r in registros
if any(r[0].startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS)
]
logger.info( logger.info(
"Registros jurídicos por prefijo: %d de %d totales", "Registros jurídicos por prefijo y longitud: %d de %d totales",
len(filtrados), len(registros), len(filtrados), len(registros),
) )
return filtrados return filtrados
def filtrar_no_existentes(registros, rucs_existentes): def filtrar_no_existentes(registros, rucs_existentes):
"""Deja solo los registros cuyo RUC NO está en la tabla personas.""" """
faltantes = [r for r in registros if r[0] not in rucs_existentes] Deja solo los registros cuyo "ruc-dv" (tal cual se guarda en personas para las
jurídicas) NO está en la tabla.
"""
faltantes = [r for r in registros if f"{r[0]}-{r[2]}" not in rucs_existentes]
logger.info( logger.info(
"RUC no encontrados en la BD: %d de %d jurídicos", "RUC no encontrados en la BD: %d de %d jurídicos",
len(faltantes), len(registros), len(faltantes), len(registros),
) )
return faltantes return faltantes
def filtrar_fisicas(registros):
"""
registros: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen)
Devuelve los que NO corresponden a persona jurídica (complemento de filtrar_juridicas).
"""
filtrados = [r for r in registros if not _es_juridica(r[0])]
logger.info(
"Registros físicos (complemento de jurídicos): %d de %d totales",
len(filtrados), len(registros),
)
return filtrados
def clasificar_passwords_fisicas(registros_fisicas, passwords_existentes):
"""
registros_fisicas: lista de tuplas (ruc, razon_social, dv, codigo, estado, archivo_origen).
passwords_existentes: dict {ruc: password_actual} de personas físicas ya cargadas en la BD.
Compara el dv parseado del DNIT contra el password actual en la BD (no escribe nada,
solo clasifica para exportar a CSV y que la carga se haga aparte):
- password ya coincide con el dv -> no se toca.
- persona existe pero el password está vacío -> acción INSERTAR.
- persona existe con un password distinto -> acción ACTUALIZAR.
- el RUC no existe como persona física en la BD -> no se puede insertar una fila nueva
(faltan nombres, apellidos, fecha de nacimiento, etc. que el DNIT no provee),
se descarta y se loguea.
Devuelve (a_generar, no_encontrados):
- a_generar: lista de tuplas (ruc, razon_social, dv, codigo, estado) listas para
exportar a CSV (mismo formato de 5 campos que trae el DNIT).
- no_encontrados: lista de los registros originales cuyo RUC no está en la BD.
"""
a_generar = []
no_encontrados = []
sin_cambios = 0
a_insertar = 0
a_actualizar = 0
for registro in registros_fisicas:
ruc, razon_social, dv, codigo, estado, _archivo_origen = registro
if ruc not in passwords_existentes:
no_encontrados.append(registro)
continue
password_actual = (passwords_existentes[ruc] or "").strip()
if password_actual == dv:
sin_cambios += 1
continue
if password_actual:
a_actualizar += 1
else:
a_insertar += 1
a_generar.append((ruc, razon_social, dv, codigo, estado))
logger.info(
"Personas físicas: %d sin cambios, %d a insertar, %d a actualizar, %d no encontradas en la BD",
sin_cambios, a_insertar, a_actualizar, len(no_encontrados),
)
if no_encontrados:
logger.warning(
"Personas físicas no encontradas en la BD (se omiten, no se generan filas nuevas): %s",
", ".join(r[0] for r in no_encontrados[:20])
+ (f" ... (+{len(no_encontrados) - 20} más)" if len(no_encontrados) > 20 else ""),
)
return a_generar, no_encontrados

View File

@@ -1,14 +1,29 @@
import logging import logging
import os
from datetime import datetime
from config import LOG_DIR
from extractor import descomprimir_todo from extractor import descomprimir_todo
from parser import recorrer_y_parsear from parser import recorrer_y_parsear
from filtro import filtrar_juridicas, filtrar_no_existentes from filtro import (
filtrar_juridicas,
filtrar_no_existentes,
filtrar_fisicas,
clasificar_passwords_fisicas,
)
from exportador import exportar_csv from exportador import exportar_csv
from db import get_connection, fetch_rucs_existentes from db import get_connection, fetch_rucs_existentes, fetch_passwords_fisicas
os.makedirs(LOG_DIR, exist_ok=True)
LOG_FILE = os.path.join(LOG_DIR, f"bot_{datetime.now():%Y%m%d_%H%M%S}.log")
logging.basicConfig( logging.basicConfig(
level=logging.INFO, level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s", format="%(asctime)s [%(levelname)s] %(message)s",
handlers=[
logging.FileHandler(LOG_FILE, encoding="utf-8"),
logging.StreamHandler(),
],
) )
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@@ -36,9 +51,22 @@ def main():
faltantes = filtrar_no_existentes(juridicas, rucs_existentes) faltantes = filtrar_no_existentes(juridicas, rucs_existentes)
logger.info("Paso 5: exportando CSV de RUC faltantes") logger.info("Paso 5: exportando CSV de RUC faltantes")
rutas = exportar_csv(faltantes) rutas = exportar_csv([r[:5] for r in faltantes])
logger.info("Bot finalizado. Archivos generados: %s", rutas) logger.info("Paso 6: comparando password de personas físicas contra el dv del DNIT")
fisicas = filtrar_fisicas(registros)
conn = get_connection()
try:
passwords_existentes = fetch_passwords_fisicas(conn)
finally:
conn.close()
a_generar, _no_encontrados = clasificar_passwords_fisicas(fisicas, passwords_existentes)
logger.info("Paso 7: exportando CSV de personas físicas a insertar/actualizar password")
rutas_passwords = exportar_csv(a_generar, prefijo_nombre="fisicas_password")
logger.info("Bot finalizado. Archivos generados: %s", rutas + rutas_passwords)
if __name__ == "__main__": if __name__ == "__main__":

View File

@@ -36,19 +36,19 @@ def recorrer_y_parsear(directorio_raiz=BASE_DIR):
""" """
registros = [] registros = []
for carpeta_actual, _subcarpetas, archivos in os.walk(directorio_raiz): for carpeta_actual, _subcarpetas, archivos in sorted(os.walk(directorio_raiz)):
for nombre in archivos: for nombre in sorted(archivos):
if not nombre.lower().endswith(".txt"): if not nombre.lower().endswith(".txt"):
continue continue
ruta_txt = os.path.join(carpeta_actual, nombre) ruta_txt = os.path.join(carpeta_actual, nombre)
try: try:
with open(ruta_txt, "r", encoding="latin-1") as f: with open(ruta_txt, "r", encoding="utf-8") as f:
for linea in f: for linea in f:
registro = _parsear_linea(linea, nombre) registro = _parsear_linea(linea, nombre)
if registro: if registro:
registros.append(registro) registros.append(registro)
except OSError as e: except (OSError, UnicodeDecodeError) as e:
logger.error("No se pudo leer %s: %s", ruta_txt, e) logger.error("No se pudo leer %s: %s", ruta_txt, e)
logger.info("Total de registros parseados: %d", len(registros)) logger.info("Total de registros parseados: %d", len(registros))