Update core.py

core.py

@@ -1,26 +1,27 @@
-# Versión 2.3: Core con Comparación Palabra por Palabra (Precisión Alta)
-# Autor: Gemini (AI Assistant)
-
+# Versión 2.4
 import os
 import zipfile
 import uuid
 import subprocess
 import difflib
+import io 
 import pdfplumber
 import pandas as pd
-from pypdf import PdfWriter, PdfReader
+from pypdf import PdfWriter, PdfReader, Transformation
 from pdf2image import convert_from_path
 from pdf2docx import Converter
 from PIL import Image
 from pptx import Presentation
 from pptx.util import Inches
 
-# ReportLab para generar el PDF de diferencias
-from reportlab.lib.pagesizes import A4
+# ReportLab para generar PDFs (Informes y Capas de texto)
+from reportlab.lib.pagesizes import A4, letter
 from reportlab.lib import colors
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.enums import TA_JUSTIFY
+from reportlab.pdfgen import canvas 
+from reportlab.lib.units import inch 
 
 from config import TEMP_DIR
 
@@ -102,20 +103,127 @@ class PDFEngine:
         return sorted(list(set(key_pages)))
 
     # --- CORE PDF TOOLS ---
-    def merge_pdfs(self, file_paths: list, order_indices: list = None) -> str:
+
+    def merge_pdfs(self, file_paths: list, order_indices: list = None, use_numbering: bool = False) -> str:
         if not file_paths: raise ValueError("No hay archivos.")
+        
+        # 1. Ordenar
         ordered = []
         if order_indices and len(order_indices) == len(file_paths):
             try: ordered = [file_paths[int(i)] for i in order_indices]
             except: ordered = file_paths
         else: ordered = file_paths
+        
+        # 2. Unir
         m = PdfWriter()
         for p in ordered: m.append(p)
-        out = self._get_output_path("unido.pdf")
-        with open(out, "wb") as f: m.write(f)
-        m.close()
+        
+        temp_out = self._get_output_path("temp_unido.pdf")
+        with open(temp_out, "wb") as f: m.write(f)
+        
+        # 3. Numerar (Si se solicitó)
+        if use_numbering:
+            final_out = self._add_page_numbers(temp_out)
+            # Intentar borrar el intermedio para no acumular basura (aunque el cron lo haría)
+            try: os.remove(temp_out) 
+            except: pass
+            return final_out
+        
+        return temp_out
+
+    def _add_page_numbers(self, file_path: str) -> str:
+        reader = PdfReader(file_path)
+        writer = PdfWriter()
+        num_pages = len(reader.pages)
+
+        for i, page in enumerate(reader.pages):
+            # Crear un PDF en memoria con solo el número de página
+            packet = io.BytesIO()
+            # Usamos canvas de reportlab
+            can = canvas.Canvas(packet, pagesize=letter)
+            
+            # Obtener tamaño de la página original para centrar el número
+            page_width = float(page.mediabox.width)
+            
+            # Dibujar texto: "Página X de Y" en el centro inferior
+            text = f"Página {i+1} de {num_pages}"
+            can.setFont("Helvetica", 10)
+            can.drawCentredString(page_width / 2.0, 20, text) # 20 puntos desde abajo
+            can.save()
+
+            # Mover al inicio del buffer
+            packet.seek(0)
+            new_pdf = PdfReader(packet)
+            
+            # Fusionar la capa del número con la página original
+            page.merge_page(new_pdf.pages[0])
+            writer.add_page(page)
+
+        out = self._get_output_path("unido_numerado.pdf")
+        with open(out, "wb") as f: writer.write(f)
         return out
 
+    def add_watermark(self, file_path: str, text: str) -> str:
+        if not file_path or not text: raise ValueError("Falta archivo o texto.")
+        
+        reader = PdfReader(file_path)
+        writer = PdfWriter()
+
+        # Crear la marca de agua en memoria una sola vez
+        packet = io.BytesIO()
+        can = canvas.Canvas(packet, pagesize=letter)
+        can.setFont("Helvetica-Bold", 50)
+        can.setFillColorRGB(0.5, 0.5, 0.5, 0.3) # Gris semi-transparente
+        
+        # Guardar estado, rotar y escribir en el centro (aprox)
+        can.saveState()
+        can.translate(300, 400) # Mover origen al centro aprox
+        can.rotate(45) # Rotar 45 grados
+        can.drawCentredString(0, 0, text)
+        can.restoreState()
+        can.save()
+
+        packet.seek(0)
+        watermark_pdf = PdfReader(packet)
+        watermark_page = watermark_pdf.pages[0]
+
+        # Aplicar a todas las páginas
+        for page in reader.pages:
+            # Es necesario clonar el objeto watermark para cada pagina o pypdf se queja a veces
+            page.merge_page(watermark_page) 
+            writer.add_page(page)
+
+        out = self._get_output_path("marca_agua.pdf")
+        with open(out, "wb") as f: writer.write(f)
+        return out
+
+    # --- NUEVO: Reparador (Ghostscript) ---
+    def repair_pdf(self, file_path: str) -> str:
+        if not file_path: raise ValueError("Falta archivo.")
+        
+        out = self._get_output_path("reparado.pdf")
+        
+        # Comando mágico de Ghostscript para regenerar PDFs
+        # -sDEVICE=pdfwrite : Reescribe el PDF
+        # -dPDFSETTINGS=/default : Calidad normal
+        cmd = [
+            "gs",
+            "-o", out,               # Output file
+            "-sDEVICE=pdfwrite",     
+            "-dPDFSETTINGS=/default",
+            "-dInteract=N",          # No interactivo
+            "-dNOPAUSE", "-dQUIET", "-dBATCH",
+            file_path
+        ]
+        
+        try:
+            subprocess.run(cmd, check=True)
+            return out
+        except subprocess.CalledProcessError:
+            raise RuntimeError("Ghostscript no pudo reparar el archivo (daño severo).")
+        except Exception as e:
+            raise RuntimeError(f"Error sistema: {e}")
+
     def split_pdf_custom(self, file_path: str, range_str: str) -> str:
         if not file_path: raise ValueError("Falta archivo.")
         r = PdfReader(file_path)
@@ -208,12 +316,8 @@ class PDFEngine:
             return out
         except Exception as e: raise RuntimeError(f"Error: {e}")
 
-    # --- COMPARACIÓN DE TEXTO PALABRA POR PALABRA (v2.3) ---
+    # --- COMPARACIÓN DE TEXTO PALABRA POR PALABRA ---
     def compare_pdfs_text(self, path_a: str, path_b: str) -> str:
-        """
-        Compara el TEXTO de dos PDFs tokenizando por PALABRAS.
-        Esto evita que líneas enteras se marquen como erróneas si solo cambia una palabra.
-        """
         if not path_a or not path_b: raise ValueError("Faltan archivos.")
 
         def get_all_words(path):
@@ -223,24 +327,18 @@ class PDFEngine:
                 for page in reader.pages:
                     extracted = page.extract_text()
                     if extracted: text += extracted + " "
-                # Tokenizar por palabras (split elimina espacios extra y saltos de línea)
                 return text.split()
             except Exception as e:
                 raise RuntimeError(f"Error leyendo PDF: {e}")
 
-        # Obtenemos listas de palabras ['La', 'casa', 'es', 'roja'...]
         words_a = get_all_words(path_a)
         words_b = get_all_words(path_b)
-
-        # Calculamos diferencias palabra por palabra
         diff = difflib.ndiff(words_a, words_b)
 
-        # Generar PDF
         output_path = self._get_output_path("informe_diferencias_palabras.pdf")
         doc = SimpleDocTemplate(output_path, pagesize=A4)
         styles = getSampleStyleSheet()
         
-        # Estilo para el cuerpo del texto
         style_body = ParagraphStyle(
             'Body', 
             parent=styles['BodyText'], 
@@ -253,57 +351,44 @@ class PDFEngine:
         story.append(Paragraph("Informe de Comparación (Modo Palabras)", styles['Heading1']))
         story.append(Spacer(1, 12))
         
-        # Leyenda
         legend = '<b>Leyenda:</b> <font color="red"><strike>Eliminado</strike></font> | <font color="green"><b>Añadido</b></font> | Texto Común'
         story.append(Paragraph(legend, style_body))
         story.append(Spacer(1, 12))
         story.append(Paragraph(f"<b>A:</b> {os.path.basename(path_a)} | <b>B:</b> {os.path.basename(path_b)}", style_body))
         story.append(Spacer(1, 12))
 
-        # Reconstrucción del texto
-        # Acumularemos fragmentos HTML para crear párrafos.
-        # ReportLab tiene límites de tamaño por párrafo, así que hacemos "flush" cada cierto tiempo.
-        
         current_html = ""
         word_count = 0
         
         for token in diff:
             code = token[:2]
             word = token[2:]
-            
-            # Escapar caracteres especiales XML
             safe_word = word.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
             
             chunk = ""
             if code == '- ':
-                # Eliminado (Rojo + Tachado)
                 chunk = f'<font color="red"><strike>{safe_word}</strike></font> '
             elif code == '+ ':
-                # Añadido (Verde + Negrita)
                 chunk = f'<font color="green"><b>{safe_word}</b></font> '
             elif code == '  ':
-                # Igual (Negro)
                 chunk = f'{safe_word} '
-            # Ignoramos líneas '?'
             
             current_html += chunk
             word_count += 1
             
-            # Crear un nuevo párrafo cada ~300 palabras para evitar problemas de renderizado
-            if word_count > 300 and code == '  ': # Cortar preferiblemente en texto normal
+            if word_count > 300 and code == '  ': 
                 story.append(Paragraph(current_html, style_body))
                 story.append(Spacer(1, 6))
                 current_html = ""
                 word_count = 0
 
-        # Añadir el resto
         if current_html:
             story.append(Paragraph(current_html, style_body))
 
         doc.build(story)
         return output_path
 
-    # --- CONVERSIONES OFFICE (v2.0) ---
+    # --- CONVERSIONES OFFICE ---
     def pdf_to_excel(self, f):
         if not f: raise ValueError("Falta archivo.")
         try: