Bot 2: Script funcional para el procesamiento y filtrado de los archivos descargados
This commit is contained in:
@@ -20,6 +20,11 @@ MARKER_SUFFIX = ".procesado"
|
||||
# TODO: completar con la lista real (por ahora solo los dos ejemplos dados).
|
||||
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_PERSONAS = os.getenv("TABLA_PERSONAS", "personas")
|
||||
COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc")
|
||||
@@ -28,4 +33,7 @@ COLUMNA_RUC = os.getenv("COLUMNA_RUC", "ruc")
|
||||
CSV_CHUNK_SIZE = 80000
|
||||
|
||||
# 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)
|
||||
38
app/db.py
38
app/db.py
@@ -1,4 +1,5 @@
|
||||
import logging
|
||||
import re
|
||||
|
||||
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__)
|
||||
|
||||
_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():
|
||||
return pymysql.connect(
|
||||
@@ -21,8 +35,9 @@ def get_connection():
|
||||
|
||||
def fetch_rucs_existentes(conn):
|
||||
"""
|
||||
Trae todos los RUC ya cargados en la tabla personas y los devuelve
|
||||
como set (lookup O(1) para comparar contra los parseados del DNIT).
|
||||
Trae todos los RUC ya cargados en la tabla personas, tal cual están guardados
|
||||
(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}"
|
||||
existentes = set()
|
||||
@@ -31,4 +46,21 @@ def fetch_rucs_existentes(conn):
|
||||
for (ruc,) in cur.fetchall():
|
||||
existentes.add(str(ruc).strip())
|
||||
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
|
||||
@@ -6,10 +6,10 @@ from config import OUTPUT_DIR, CSV_CHUNK_SIZE
|
||||
|
||||
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.
|
||||
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")
|
||||
with open(ruta, "w", newline="", encoding="utf-8") as f:
|
||||
writer = csv.writer(f)
|
||||
writer.writerow(ENCABEZADO)
|
||||
writer.writerow(encabezado)
|
||||
writer.writerows(bloque)
|
||||
|
||||
rutas.append(ruta)
|
||||
|
||||
102
app/filtro.py
102
app/filtro.py
@@ -1,31 +1,113 @@
|
||||
import logging
|
||||
|
||||
from config import PREFIJOS_PERSONAS_JURIDICAS
|
||||
from config import PREFIJOS_PERSONAS_JURIDICAS, LONGITUD_RUC_JURIDICA
|
||||
|
||||
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):
|
||||
"""
|
||||
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 = [
|
||||
r for r in registros
|
||||
if any(r[0].startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS)
|
||||
]
|
||||
filtrados = [r for r in registros if _es_juridica(r[0])]
|
||||
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),
|
||||
)
|
||||
return filtrados
|
||||
|
||||
|
||||
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(
|
||||
"RUC no encontrados en la BD: %d de %d jurídicos",
|
||||
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
|
||||
36
app/main.py
36
app/main.py
@@ -1,14 +1,29 @@
|
||||
import logging
|
||||
import os
|
||||
from datetime import datetime
|
||||
|
||||
from config import LOG_DIR
|
||||
from extractor import descomprimir_todo
|
||||
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 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(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] %(message)s",
|
||||
handlers=[
|
||||
logging.FileHandler(LOG_FILE, encoding="utf-8"),
|
||||
logging.StreamHandler(),
|
||||
],
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -36,9 +51,22 @@ def main():
|
||||
faltantes = filtrar_no_existentes(juridicas, rucs_existentes)
|
||||
|
||||
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__":
|
||||
|
||||
@@ -36,19 +36,19 @@ def recorrer_y_parsear(directorio_raiz=BASE_DIR):
|
||||
"""
|
||||
registros = []
|
||||
|
||||
for carpeta_actual, _subcarpetas, archivos in os.walk(directorio_raiz):
|
||||
for nombre in archivos:
|
||||
for carpeta_actual, _subcarpetas, archivos in sorted(os.walk(directorio_raiz)):
|
||||
for nombre in sorted(archivos):
|
||||
if not nombre.lower().endswith(".txt"):
|
||||
continue
|
||||
|
||||
ruta_txt = os.path.join(carpeta_actual, nombre)
|
||||
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:
|
||||
registro = _parsear_linea(linea, nombre)
|
||||
if 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.info("Total de registros parseados: %d", len(registros))
|
||||
|
||||
Reference in New Issue
Block a user