Update core.py

core.py

@@ -1,99 +1,167 @@
-# Versión 1.0: Lógica para Unir, Dividir y Proteger PDFs
+# Versión 1.1: Soporte para rangos, reordenamiento y previsualización (poppler)
 import os
 from pypdf import PdfWriter, PdfReader
+from pdf2image import convert_from_path
 from config import TEMP_DIR
 import uuid
 
 class PDFEngine:
-    """
-    Motor de procesamiento de PDFs.
-    Principio SRP: Solo se encarga de manipular bytes y archivos.
-    """
-
+    
     @staticmethod
     def _get_output_path(filename: str) -> str:
-        """Genera una ruta única para evitar colisiones."""
         unique_name = f"{uuid.uuid4().hex[:8]}_{filename}"
         return os.path.join(TEMP_DIR, unique_name)
 
-    def merge_pdfs(self, file_paths: list) -> str:
+    def get_pdf_info(self, file_path: str) -> dict:
+        """Obtiene metadatos básicos del PDF."""
+        try:
+            reader = PdfReader(file_path)
+            return {"pages": len(reader.pages), "name": os.path.basename(file_path)}
+        except Exception:
+            return {"pages": 0, "name": "Error"}
+
+    def generate_preview(self, file_path: str, page_number: int) -> str:
+        """
+        Genera una imagen de una página específica.
+        Args:
+            page_number: Número de página (1-based index para el usuario)
+        """
+        try:
+            # Convertir solo la página solicitada (first_page es 1-based, last_page es 1-based)
+            images = convert_from_path(
+                file_path, 
+                first_page=page_number, 
+                last_page=page_number,
+                size=(None, 400) # Altura fija para eficiencia
+            )
+            if images:
+                output_path = self._get_output_path(f"preview_pg{page_number}.jpg")
+                images[0].save(output_path, "JPEG")
+                return output_path
+            return None
+        except Exception as e:
+            print(f"Error generando preview: {e}")
+            return None
+
+    def merge_pdfs(self, file_paths: list, order_indices: list = None) -> str:
         """
-        Une múltiples PDFs en uno solo.
+        Une PDFs permitiendo reordenamiento.
         Args:
-            file_paths: Lista de rutas de archivos temporales.
-        Returns:
-            Ruta del archivo generado.
+            order_indices: Lista de enteros indicando el orden (ej: [2, 0, 1]).
+                           Si es None, usa el orden de llegada.
         """
         if not file_paths:
-            raise ValueError("No se han proporcionado archivos.")
+            raise ValueError("No hay archivos para unir.")
+
+        # Reordenar si se especifican índices
+        ordered_paths = []
+        if order_indices:
+            try:
+                # Validar que los índices estén dentro del rango
+                if len(order_indices) != len(file_paths):
+                     # Fallback si las longitudes no coinciden
+                     ordered_paths = file_paths
+                else:
+                    for idx in order_indices:
+                        ordered_paths.append(file_paths[int(idx)])
+            except (ValueError, IndexError):
+                # Si el usuario mete datos inválidos, usamos orden original
+                ordered_paths = file_paths
+        else:
+            ordered_paths = file_paths
 
         merger = PdfWriter()
-        
         try:
-            for path in file_paths:
+            for path in ordered_paths:
                 merger.append(path)
             
-            output_path = self._get_output_path("unido.pdf")
+            output_path = self._get_output_path("unido_ordenado.pdf")
             with open(output_path, "wb") as f:
                 merger.write(f)
-            
             return output_path
         except Exception as e:
-            raise RuntimeError(f"Error al unir PDFs: {str(e)}")
+            raise RuntimeError(f"Error al unir: {str(e)}")
         finally:
             merger.close()
 
-    def split_pdf(self, file_path: str) -> list:
+    def parse_range_string(self, range_str: str, max_pages: int) -> list:
         """
-        Divide un PDF en páginas individuales.
-        Nota: Devuelve una lista de archivos.
+        Convierte "1-3, 5" en [0, 1, 2, 4] (0-based indices).
         """
+        pages = set()
+        parts = range_str.split(',')
+        
+        for part in parts:
+            part = part.strip()
+            if '-' in part:
+                try:
+                    start, end = map(int, part.split('-'))
+                    # Ajustar a rango válido y convertir a 0-index
+                    start = max(1, start)
+                    end = min(max_pages, end)
+                    if start <= end:
+                        for p in range(start - 1, end):
+                            pages.add(p)
+                except ValueError:
+                    continue
+            else:
+                try:
+                    p = int(part)
+                    if 1 <= p <= max_pages:
+                        pages.add(p - 1)
+                except ValueError:
+                    continue
+        
+        return sorted(list(pages))
+
+    def split_pdf_custom(self, file_path: str, range_str: str) -> list:
+        """Divide basándose en un rango string."""
         if not file_path:
             raise ValueError("Archivo no proporcionado.")
 
-        output_files = []
-        try:
-            reader = PdfReader(file_path)
-            base_name = os.path.basename(file_path).replace(".pdf", "")
+        reader = PdfReader(file_path)
+        total_pages = len(reader.pages)
+        
+        # Obtener índices (0-based) a extraer
+        selected_indices = self.parse_range_string(range_str, total_pages)
+        
+        if not selected_indices:
+            raise ValueError("El rango proporcionado no es válido o está vacío.")
 
-            for i, page in enumerate(reader.pages):
-                writer = PdfWriter()
-                writer.add_page(page)
-                
-                out_name = f"{base_name}_pag_{i+1}.pdf"
-                out_path = self._get_output_path(out_name)
-                
-                with open(out_path, "wb") as f:
-                    writer.write(f)
-                
-                output_files.append(out_path)
+        output_files = []
+        base_name = os.path.basename(file_path).replace(".pdf", "")
+        
+        # Agrupar páginas consecutivas podría ser una opción, 
+        # pero la herramienta dice "Dividir", así que generamos un PDF por selección 
+        # o un solo PDF con la selección? 
+        # Interpretación estándar: "Extraer páginas" -> Crea un nuevo PDF con SOLO esas páginas
+        # Interpretación "Split": Rompe en archivos.
+        # Asumiré: Crear UN nuevo archivo con las páginas seleccionadas (Extract).
+        
+        writer = PdfWriter()
+        for idx in selected_indices:
+            writer.add_page(reader.pages[idx])
             
-            return output_files
-        except Exception as e:
-            raise RuntimeError(f"Error al dividir PDF: {str(e)}")
+        out_name = f"{base_name}_extracto.pdf"
+        output_path = self._get_output_path(out_name)
+        
+        with open(output_path, "wb") as f:
+            writer.write(f)
+            
+        return output_path # Retornamos str, no lista, para esta variante de extracción.
 
     def protect_pdf(self, file_path: str, password: str) -> str:
-        """
-        Encripta un PDF con contraseña.
-        """
+        # (Sin cambios respecto a v1.0, mantener código anterior)
+        # ... (copiar lógica previa) ...
+        # Por brevedad en la respuesta, asumo que mantienes el método protect_pdf de la v1.0
         if not file_path or not password:
-            raise ValueError("Faltan el archivo o la contraseña.")
-
+            raise ValueError("Faltan datos")
         try:
             reader = PdfReader(file_path)
             writer = PdfWriter()
-
-            # Copiar todas las páginas
-            for page in reader.pages:
-                writer.add_page(page)
-
-            # Encriptar
+            for page in reader.pages: writer.add_page(page)
             writer.encrypt(password)
-
             output_path = self._get_output_path("protegido.pdf")
-            with open(output_path, "wb") as f:
-                writer.write(f)
-            
+            with open(output_path, "wb") as f: writer.write(f)
             return output_path
-        except Exception as e:
-            raise RuntimeError(f"Error al proteger PDF: {str(e)}")
+        except Exception as e: raise RuntimeError(f"Error: {e}")