Cómo procesar miles de PDFs eficientemente: estrategias avanzadas

La forma más rápida de aumentar el throughput al procesar miles de PDFs es ejecutar múltiples procesos en paralelo, aprovechando todos los núcleos del procesador. Python con `multiprocessing` o `concurrent.futures` hace esto sencillo: ```python import glob import os import subprocess from concurrent.futures import ProcessPoolExecutor, as_completed from multiprocessing import cpu_count def comprimir_pdf(pdf_path): salida = pdf_path.replace('.pdf', '_c.pdf') if os.path.exists(salida): return pdf_path, 'ya_procesado' result = subprocess.run([ 'gs', '-sDEVICE=pdfwrite', '-dPDFSETTINGS=/ebook', '-dNOPAUSE', '-dQUIET', '-dBATCH', '-sColorConversionStrategy=RGB', f'-sOutputFile={salida}', pdf_path ], capture_output=True) if result.returncode == 0: reduccion = (1 - os.path.getsize(salida)/os.path.getsize(pdf_path)) * 100 return pdf_path, f'{reduccion:.0f}%' else: return pdf_path, f'ERROR: {result.stderr.decode()[:50]}' pdfs = glob.glob('/ruta/a/pdfs/**/*.pdf', recursive=True) num_workers = max(1, cpu_count() - 1) # Dejar un núcleo libre print(f'Procesando {len(pdfs)} PDFs con {num_workers} workers paralelos...') with ProcessPoolExecutor(max_workers=num_workers) as executor: futuros = {executor.submit(comprimir_pdf, pdf): pdf for pdf in pdfs} completados = 0 errores = [] for futuro in as_completed(futuros): ruta, resultado = futuro.result() completados += 1 if 'ERROR' in str(resultado): errores.append(ruta) if completados % 100 == 0: print(f'Progreso: {completados}/{len(pdfs)} ({completados/len(pdfs)*100:.1f}%)') print(f'\nCompletado. Errores: {len(errores)}') ``` Con 8 núcleos disponibles, este script procesa hasta 8 PDFs simultáneamente, multiplicando por 7-8 la velocidad respecto al procesamiento secuencial.

1. 1Determina el número de núcleos disponibles en tu servidor con el comando 'nproc' (Linux/macOS).
2. 2Configura el número de workers en el script: usa cpu_count() - 1 para dejar un núcleo libre para el sistema.
3. 3Ejecuta el script y monitoriza el uso de CPU con 'htop' o 'top' para verificar la paralelización.
4. 4Ajusta el número de workers si el sistema se queda sin memoria RAM (reduce workers) o si la CPU no está al 100% (aumenta workers).

Cuando procesas decenas de miles de PDFs, la gestión de memoria es crítica. Ghostscript puede consumir hasta 2-4x el tamaño del PDF de entrada en RAM durante el procesamiento. Con 100 workers paralelos procesando PDFs de 50 MB cada uno, necesitarías 20 GB de RAM solo para el procesamiento. Estrategias para controlar el consumo de memoria: Limitar workers según RAM disponible: ```python import psutil ram_disponible_gb = psutil.virtual_memory().available / (1024**3) tamano_pdf_tipico_gb = 0.05 # 50 MB = 0.05 GB factor_overhead = 3 # Ghostscript usa ~3x el tamaño del PDF max_workers_ram = int(ram_disponible_gb / (tamano_pdf_tipico_gb * factor_overhead)) num_workers = min(cpu_count() - 1, max_workers_ram) print(f'Workers configurados: {num_workers} (limitado por RAM disponible)') ``` Procesar en batches para controlar el pico de memoria: ```python batch_size = 50 # Procesar 50 PDFs antes de hacer pausa for i in range(0, len(pdfs), batch_size): batch = pdfs[i:i+batch_size] # Procesar batch... # El garbage collector libera memoria entre batches ```

Con miles de PDFs, la probabilidad de encontrar archivos corruptos, PDFs con contraseña que no puedes abrir, archivos con codificaciones no estándar o PDFs que hacen que Ghostscript consuma infinita memoria es significativa. Tu pipeline debe ser robusto frente a todos estos casos. Verificación pre-procesamiento: ```python from pypdf import PdfReader def verificar_pdf(ruta): try: reader = PdfReader(ruta) if reader.is_encrypted: return False, 'PDF cifrado' num_paginas = len(reader.pages) if num_paginas == 0: return False, 'PDF sin páginas' return True, f'{num_paginas} páginas' except Exception as e: return False, str(e) # Separar PDFs válidos de inválidos antes de procesar validos = [] invalidos = [] for pdf in pdfs: ok, msg = verificar_pdf(pdf) (validos if ok else invalidos).append((pdf, msg)) print(f'PDFs válidos: {len(validos)}, inválidos: {len(invalidos)}') ``` Timeout por archivo para evitar que Ghostscript se cuelgue: ```python result = subprocess.run(comando, timeout=120, capture_output=True) # Si tarda más de 120 segundos, mata el proceso ```

Para organizaciones que necesitan procesar PDFs continuamente (no solo un lote histórico único), la arquitectura de pipeline es más adecuada que los scripts de ejecución única: Arquitectura recomendada: 1. Cola de mensajes (Redis, RabbitMQ, o simplemente una carpeta con sistema de archivos): los PDFs nuevos se añaden a la cola cuando llegan. 2. Workers de procesamiento: múltiples procesos Python que consumen la cola y procesan los PDFs. Se pueden escalar horizontalmente añadiendo más workers. 3. Base de datos de estado (SQLite para volúmenes pequeños, PostgreSQL para grandes): registra qué PDFs se han procesado, con qué resultado, cuándo, y los metadatos de tamaño antes/después. 4. Sistema de alertas: notificaciones cuando el error rate supera un umbral, cuando la cola crece demasiado, o cuando un worker falla. Para volúmenes muy grandes (más de 10,000 PDFs por día), considera Celery (Python) como sistema de colas y workers distribuidos, con Flower para monitorización visual del estado de la cola. Este tipo de arquitectura puede procesar cientos de miles de PDFs por día de forma sostenida con hardware modesto (un servidor con 8-16 núcleos y 32 GB de RAM).