Estructura inicial del proyecto DNIT BOT AUTO

This commit is contained in:
2026-09-15 16:54:29 -03:00
parent 8993df7d30
commit 221e236d73
12 changed files with 362 additions and 0 deletions

31
app/config.py Normal file
View File

@@ -0,0 +1,31 @@
import os
# Directorio base donde llegan los .zip descargados por el otro bot
BASE_DIR = os.getenv("BASE_DIR", "/data/Documentos Descargados")
# Carpeta donde se descomprimen los .zip (por defecto, dentro del mismo BASE_DIR)
EXTRACT_DIR = os.getenv("EXTRACT_DIR", BASE_DIR)
# Conexión a la base de datos (MySQL). Ajustar si Criterion usa otro motor.
DB_HOST = os.getenv("DB_HOST", "db")
DB_PORT = int(os.getenv("DB_PORT", "3306"))
DB_USER = os.getenv("DB_USER", "botdnit")
DB_PASSWORD = os.getenv("DB_PASSWORD", "botdnit")
DB_NAME = os.getenv("DB_NAME", "botdnit")
# Marca los .zip ya procesados para no descomprimir de nuevo en cada corrida
MARKER_SUFFIX = ".procesado"
# Prefijos de RUC que identifican persona jurídica.
# TODO: completar con la lista real (por ahora solo los dos ejemplos dados).
PREFIJOS_PERSONAS_JURIDICAS = ["8000", "801"]
# 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")
# Tamaño de cada CSV de salida
CSV_CHUNK_SIZE = 80000
# Carpeta donde se escriben los CSV con los RUC faltantes
OUTPUT_DIR = os.getenv("OUTPUT_DIR", "/data/salida")

34
app/db.py Normal file
View File

@@ -0,0 +1,34 @@
import logging
import pymysql
from config import DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME, TABLA_PERSONAS, COLUMNA_RUC
logger = logging.getLogger(__name__)
def get_connection():
return pymysql.connect(
host=DB_HOST,
port=DB_PORT,
user=DB_USER,
password=DB_PASSWORD,
database=DB_NAME,
charset="utf8mb4",
autocommit=True,
)
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).
"""
query = f"SELECT {COLUMNA_RUC} FROM {TABLA_PERSONAS}"
existentes = set()
with conn.cursor() as cur:
cur.execute(query)
for (ruc,) in cur.fetchall():
existentes.add(str(ruc).strip())
logger.info("RUC existentes en %s: %d", TABLA_PERSONAS, len(existentes))
return existentes

37
app/exportador.py Normal file
View File

@@ -0,0 +1,37 @@
import csv
import logging
import os
from config import OUTPUT_DIR, CSV_CHUNK_SIZE
logger = logging.getLogger(__name__)
ENCABEZADO = ["ruc", "razon_social", "dv", "codigo", "estado", "archivo_origen"]
def exportar_csv(registros, prefijo_nombre="rucs_faltantes"):
"""
Escribe los registros en archivos CSV de hasta CSV_CHUNK_SIZE filas cada uno.
Devuelve la lista de rutas generadas.
"""
os.makedirs(OUTPUT_DIR, exist_ok=True)
rutas = []
total = len(registros)
partes = max(1, (total + CSV_CHUNK_SIZE - 1) // CSV_CHUNK_SIZE)
for i in range(partes):
inicio = i * CSV_CHUNK_SIZE
fin = inicio + CSV_CHUNK_SIZE
bloque = registros[inicio:fin]
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.writerows(bloque)
rutas.append(ruta)
logger.info("CSV generado: %s (%d filas)", ruta, len(bloque))
return rutas

45
app/extractor.py Normal file
View File

@@ -0,0 +1,45 @@
import logging
import os
import zipfile
from config import BASE_DIR, EXTRACT_DIR, MARKER_SUFFIX
logger = logging.getLogger(__name__)
def descomprimir_todo():
"""
Recorre BASE_DIR buscando archivos .zip y los descomprime en una carpeta
con el mismo nombre (sin extensión). Usa un archivo .procesado como marca
para no volver a descomprimir en corridas posteriores.
"""
if not os.path.isdir(BASE_DIR):
raise FileNotFoundError(f"No existe el directorio base: {BASE_DIR}")
extraidos = []
for nombre in sorted(os.listdir(BASE_DIR)):
if not nombre.lower().endswith(".zip"):
continue
ruta_zip = os.path.join(BASE_DIR, nombre)
marker = ruta_zip + MARKER_SUFFIX
if os.path.exists(marker):
logger.info("Ya procesado, se omite: %s", nombre)
continue
destino = os.path.join(EXTRACT_DIR, os.path.splitext(nombre)[0])
os.makedirs(destino, exist_ok=True)
try:
with zipfile.ZipFile(ruta_zip, "r") as zf:
zf.extractall(destino)
with open(marker, "w") as f:
f.write("ok")
extraidos.append(destino)
logger.info("Descomprimido: %s -> %s", nombre, destino)
except zipfile.BadZipFile:
logger.error("Zip corrupto, se omite: %s", nombre)
return extraidos

31
app/filtro.py Normal file
View File

@@ -0,0 +1,31 @@
import logging
from config import PREFIJOS_PERSONAS_JURIDICAS
logger = logging.getLogger(__name__)
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.
"""
filtrados = [
r for r in registros
if any(r[0].startswith(prefijo) for prefijo in PREFIJOS_PERSONAS_JURIDICAS)
]
logger.info(
"Registros jurídicos por prefijo: %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]
logger.info(
"RUC no encontrados en la BD: %d de %d jurídicos",
len(faltantes), len(registros),
)
return faltantes

45
app/main.py Normal file
View File

@@ -0,0 +1,45 @@
import logging
from extractor import descomprimir_todo
from parser import recorrer_y_parsear
from filtro import filtrar_juridicas, filtrar_no_existentes
from exportador import exportar_csv
from db import get_connection, fetch_rucs_existentes
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s",
)
logger = logging.getLogger(__name__)
def main():
logger.info("Iniciando bot RUC DNIT")
logger.info("Paso 1: descomprimiendo zips nuevos")
carpetas_nuevas = descomprimir_todo()
logger.info("Carpetas descomprimidas en esta corrida: %d", len(carpetas_nuevas))
logger.info("Paso 2: recorriendo carpetas y parseando .txt")
registros = recorrer_y_parsear()
logger.info("Paso 3: filtrando personas jurídicas por prefijo de RUC")
juridicas = filtrar_juridicas(registros)
logger.info("Paso 4: comparando contra la tabla personas")
conn = get_connection()
try:
rucs_existentes = fetch_rucs_existentes(conn)
finally:
conn.close()
faltantes = filtrar_no_existentes(juridicas, rucs_existentes)
logger.info("Paso 5: exportando CSV de RUC faltantes")
rutas = exportar_csv(faltantes)
logger.info("Bot finalizado. Archivos generados: %s", rutas)
if __name__ == "__main__":
main()

55
app/parser.py Normal file
View File

@@ -0,0 +1,55 @@
import logging
import os
from config import BASE_DIR
logger = logging.getLogger(__name__)
CAMPOS_ESPERADOS = 5 # ruc, razon_social, dv, codigo, estado
def _parsear_linea(linea, archivo_origen):
linea = linea.rstrip("\n").rstrip("\r")
if not linea.strip():
return None
partes = linea.split("|")
# El formato trae un pipe final -> el último elemento queda vacío, se descarta.
# Ojo: el campo "codigo" puede venir vacío legítimamente (doble pipe "||"),
# así que NO se filtran strings vacíos en el medio, solo se saca el último.
if partes and partes[-1] == "":
partes = partes[:-1]
if len(partes) != CAMPOS_ESPERADOS:
logger.warning("Línea con formato inesperado en %s: %r", archivo_origen, linea)
return None
ruc, razon_social, dv, codigo, estado = (p.strip() for p in partes)
return (ruc, razon_social, dv, codigo, estado, archivo_origen)
def recorrer_y_parsear(directorio_raiz=BASE_DIR):
"""
Recorre recursivamente directorio_raiz, encuentra todos los .txt
y devuelve una lista de tuplas listas para insertar en la base.
"""
registros = []
for carpeta_actual, _subcarpetas, archivos in os.walk(directorio_raiz):
for nombre in 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:
for linea in f:
registro = _parsear_linea(linea, nombre)
if registro:
registros.append(registro)
except OSError as e:
logger.error("No se pudo leer %s: %s", ruta_txt, e)
logger.info("Total de registros parseados: %d", len(registros))
return registros