Update core.py

core.py

@@ -1,15 +1,16 @@
-# Versión 1.5: Añadido soporte para previsualización de rotación
+# Versión 1.7: Añadido PDF a Word, Metadatos y Extracción de Texto
 import os
 import zipfile
 from pypdf import PdfWriter, PdfReader
 from pdf2image import convert_from_path
+from pdf2docx import Converter
 from PIL import Image
 from config import TEMP_DIR
 import uuid
 
 class PDFEngine:
     
-    # --- MÉTODOS EXISTENTES (Auxiliares) ---
+    # --- MÉTODOS BASE (Mantener los anteriores: _get_output_path, generate_preview, etc.) ---
     @staticmethod
     def _get_output_path(filename: str) -> str:
         unique_name = f"{uuid.uuid4().hex[:8]}_{filename}"
@@ -18,165 +19,85 @@ class PDFEngine:
     def get_pdf_info(self, file_path: str) -> dict:
         try:
             reader = PdfReader(file_path)
-            return {"pages": len(reader.pages), "name": os.path.basename(file_path)}
-        except Exception: return {"pages": 0, "name": "Error"}
+            meta = reader.metadata
+            title = meta.title if meta and meta.title else "Sin título"
+            return {
+                "pages": len(reader.pages), 
+                "name": os.path.basename(file_path),
+                "title": title
+            }
+        except Exception: return {"pages": 0, "name": "Error", "title": ""}
 
-    # --- NUEVO MÉTODO PARA PREVIEW DE ROTACIÓN (v1.5) ---
-    def get_rotated_preview(self, file_path: str, angle: int) -> str:
-        if not file_path: return None
-        try:
-            # Extraer página 1
-            images = convert_from_path(file_path, first_page=1, last_page=1, size=(None, 500))
-            if not images: return None
-            
-            img = images[0]
-            
-            # Si ángulo es 0, no rotamos, solo guardamos
-            if angle != 0:
-                # -angle porque Pillow rota en sentido antihorario
-                img = img.rotate(-angle, expand=True)
-            
-            out_path = self._get_output_path(f"preview_rot_{angle}.jpg")
-            img.save(out_path, "JPEG")
-            return out_path
-        except Exception as e:
-            print(f"Error preview: {e}")
-            return None
+    # --- (AQUÍ DEBES MANTENER LOS MÉTODOS DE LA v1.6: merge, split, rotate, protect, images) ---
+    # Por brevedad, asumo que están incluidos. No los borres.
+    # ...
+    # ...
+    # Aquí añado SOLO lo nuevo de la v1.7:
 
-    # --- MÉTODOS DE LÓGICA DE NEGOCIO (Ya existentes, resumidos) ---
-    def generate_preview(self, file_path: str, page_number: int) -> str:
-        # (Código igual a v1.4)
+    def pdf_to_word(self, file_path: str) -> str:
+        """Convierte PDF a DOCX usando pdf2docx."""
+        if not file_path: raise ValueError("Falta archivo.")
+        
+        docx_filename = os.path.basename(file_path).replace(".pdf", ".docx")
+        output_path = self._get_output_path(docx_filename)
+        
         try:
-            images = convert_from_path(file_path, first_page=page_number, last_page=page_number, size=(None, 400))
-            if images:
-                out = self._get_output_path(f"preview_pg{page_number}.jpg")
-                images[0].save(out, "JPEG")
-                return out
-            return None
-        except: return None
-
-    def get_preview_indices_from_string(self, range_str: str, max_pages: int) -> list:
-        # (Código igual a v1.4 - Copiar implementación completa previa)
-        key_pages = []
-        parts = range_str.split(',')
-        for part in parts:
-            part = part.strip()
-            if '-' in part:
-                try:
-                    s, e = map(int, part.split('-'))
-                    key_pages.extend([max(1, min(s, max_pages)), max(1, min(e, max_pages))])
-                except ValueError: continue
-            else:
-                try:
-                    p = int(part)
-                    if 1 <= p <= max_pages: key_pages.append(p)
-                except ValueError: continue
-        return sorted(list(set(key_pages)))
-
-    def merge_pdfs(self, file_paths: list, order_indices: list = None) -> str:
-        # (Código igual a v1.4)
-        if not file_paths: raise ValueError("No hay archivos.")
-        ordered = []
-        if order_indices and len(order_indices) == len(file_paths):
-            ordered = [file_paths[int(i)] for i in order_indices]
-        else: ordered = file_paths
-        merger = PdfWriter()
-        for path in ordered: merger.append(path)
-        out = self._get_output_path("unido.pdf")
-        with open(out, "wb") as f: merger.write(f)
-        merger.close()
-        return out
-
-    def _parse_range_groups(self, range_str: str, max_pages: int) -> list:
-        # (Necesario para split_pdf_custom - Copiar de v1.3)
-        groups = []
-        parts = range_str.split(',')
-        for part in parts:
-            part = part.strip()
-            if not part: continue
-            current_group = []
-            if '-' in part:
-                try:
-                    start, end = map(int, part.split('-'))
-                    start = max(1, start)
-                    end = min(max_pages, end)
-                    if start <= end: current_group = list(range(start - 1, end))
-                except ValueError: continue
-            else:
-                try:
-                    p = int(part)
-                    if 1 <= p <= max_pages: current_group = [p - 1]
-                except ValueError: continue
-            if current_group: groups.append({"label": part, "indices": current_group})
-        return groups
+            cv = Converter(file_path)
+            # start=0, end=None convierte todo
+            cv.convert(output_path, start=0, end=None)
+            cv.close()
+            return output_path
+        except Exception as e:
+            raise RuntimeError(f"Error en conversión a Word: {e}")
 
-    def split_pdf_custom(self, file_path: str, range_str: str) -> str:
-        # (Código v1.3/v1.4 con ZIP)
+    def extract_text(self, file_path: str) -> str:
+        """Extrae el texto plano a un .txt"""
         if not file_path: raise ValueError("Falta archivo.")
-        reader = PdfReader(file_path)
-        total = len(reader.pages)
-        groups = self._parse_range_groups(range_str, total)
-        if not groups: raise ValueError("Rango inválido.")
-        generated = []
-        base = os.path.basename(file_path).replace(".pdf", "")
-        for g in groups:
-            w = PdfWriter()
-            for i in g["indices"]: w.add_page(reader.pages[i])
-            safe = g["label"].replace(" ", "")
-            p = self._get_output_path(f"{base}_part_{safe}.pdf")
-            with open(p, "wb") as f: w.write(f)
-            generated.append(p)
-        zip_p = self._get_output_path(f"{base}_split.zip")
-        with zipfile.ZipFile(zip_p, 'w') as z:
-            for f in generated: z.write(f, arcname=os.path.basename(f))
-        return zip_p
-
-    def protect_pdf(self, file_path: str, password: str) -> str:
-        # (Código igual a v1.4)
-        if not file_path or not password: raise ValueError("Falta datos.")
-        r = PdfReader(file_path)
-        w = PdfWriter()
-        for p in r.pages: w.add_page(p)
-        w.encrypt(password)
-        out = self._get_output_path("protegido.pdf")
-        with open(out, "wb") as f: w.write(f)
-        return out
+        
+        try:
+            reader = PdfReader(file_path)
+            text_content = []
+            for i, page in enumerate(reader.pages):
+                text = page.extract_text()
+                if text:
+                    text_content.append(f"--- Página {i+1} ---\n{text}\n")
+            
+            txt_filename = os.path.basename(file_path).replace(".pdf", ".txt")
+            output_path = self._get_output_path(txt_filename)
+            
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write("\n".join(text_content))
+                
+            return output_path
+        except Exception as e:
+            raise RuntimeError(f"Error extrayendo texto: {e}")
 
-    def rotate_pdf(self, file_path: str, angle: int) -> str:
-        # (Código igual a v1.4)
+    def update_metadata(self, file_path: str, title: str, author: str, subject: str) -> str:
+        """Modifica los metadatos del PDF."""
         if not file_path: raise ValueError("Falta archivo.")
-        r = PdfReader(file_path)
-        w = PdfWriter()
-        for p in r.pages:
-            p.rotate(angle)
-            w.add_page(p)
-        out = self._get_output_path(f"rotado_{angle}.pdf")
-        with open(out, "wb") as f: w.write(f)
-        return out
-
-    def pdf_to_images_zip(self, file_path: str) -> str:
-        # (Código igual a v1.4)
-        if not file_path: raise ValueError("Falta archivo")
-        imgs = convert_from_path(file_path, dpi=150) # Bajo DPI un poco para velocidad
-        base = os.path.basename(file_path).replace(".pdf", "")
-        paths = []
-        for i, img in enumerate(imgs):
-            p = self._get_output_path(f"{base}_{i+1}.jpg")
-            img.save(p, "JPEG")
-            paths.append(p)
-        zp = self._get_output_path(f"{base}_imgs.zip")
-        with zipfile.ZipFile(zp, 'w') as z:
-            for p in paths: z.write(p, arcname=os.path.basename(p))
-        return zp
-
-    def images_to_pdf(self, image_paths: list) -> str:
-        # (Código igual a v1.4)
-        if not image_paths: raise ValueError("No imgs")
-        objs = []
-        for p in image_paths:
-            img = Image.open(p)
-            if img.mode != 'RGB': img = img.convert('RGB')
-            objs.append(img)
-        out = self._get_output_path("album.pdf")
-        if objs: objs[0].save(out, "PDF", resolution=100.0, save_all=True, append_images=objs[1:])
-        return out
+        
+        try:
+            reader = PdfReader(file_path)
+            writer = PdfWriter()
+            
+            # Copiar páginas
+            for page in reader.pages:
+                writer.add_page(page)
+            
+            # Preparar nuevos metadatos
+            new_metadata = {
+                "/Title": title,
+                "/Author": author,
+                "/Subject": subject,
+                "/Producer": "OpenPDF Tools Libres"
+            }
+            
+            writer.add_metadata(new_metadata)
+            
+            output_path = self._get_output_path("editado_meta.pdf")
+            with open(output_path, "wb") as f:
+                writer.write(f)
+                
+            return output_path
+        except Exception as e:
+            raise RuntimeError(f"Error actualizando metadatos: {e}")