pdf-tool-cli 1.1.0__py3-none-any.whl

pdftool/tools/compress/panel.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import flet as ft
+from pydantic import ValidationError
+
+from pdftool.tools.compress.params import CompressParams
+from pdftool.tools.compress.spec import SPEC
+from pdftool.ui.accessibility import HelpButton
+from pdftool.ui.file_list import MultiFileToolPanel
+from pdftool.ui.panel_base import InvalidParams
+from pdftool.ui.registry import register
+
+_MODE_HELP = (
+    "Reducir al máximo: busca el archivo más pequeño posible. Algunas páginas "
+    "pueden dejar de tener texto seleccionable.\n\n"
+    "Conservar texto y enlaces: mantiene búsqueda, copiar/pegar, enlaces y "
+    "anotaciones cuando sea posible, aunque el archivo puede pesar más."
+)
+
+
+@register
+class CompressTool(MultiFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.COMPRESS
+    run_label = "Comprimir"
+    run_icon = ft.Icons.PLAY_ARROW
+    pick_label = "Añadir PDFs"
+
+    def extra_controls(self) -> list[ft.Control]:
+        self._target_field = ft.TextField(
+            label="Tamaño objetivo (MB)",
+            value="5",
+            width=200,
+            keyboard_type=ft.KeyboardType.NUMBER,
+            helper_text="Objetivo, no garantía.",
+        )
+        self._mode_dd = ft.Dropdown(
+            label="Modo de compresión",
+            width=330,  # cabe «Reducir al máximo (recomendado)» sin recortarse
+            value="max",
+            options=[
+                ft.dropdown.Option("max", "Reducir al máximo (recomendado)"),
+                ft.dropdown.Option("preserve", "Conservar texto y enlaces"),
+            ],
+        )
+        self._mode_help = HelpButton("Ayuda sobre compresión", _MODE_HELP)
+        return [
+            ft.Row(
+                [
+                    self._target_field,
+                    self._mode_dd,
+                    self._mode_help,
+                ],
+                spacing=12,
+                wrap=True,  # en ventanas estrechas pasa a dos líneas
+                # Arriba, no centrados: la ayuda «Objetivo, no garantía.» alarga
+                # el campo del objetivo y lo descuadraba frente al desplegable.
+                vertical_alignment=ft.CrossAxisAlignment.START,
+            ),
+            self._mode_help.detail,
+        ]
+
+    def make_params(self):
+        # En español se escribe «2,5»: se acepta la coma decimal.
+        text = (self._target_field.value or "").strip().replace(",", ".")
+        try:
+            return CompressParams(target_mb=float(text), mode=self._mode_dd.value)
+        except (ValueError, ValidationError) as exc:
+            raise InvalidParams(
+                "Escribe un tamaño mayor que 0, por ejemplo 5 o 2,5.",
+                field=self._target_field,
+            ) from exc

pdftool/tools/compress/params.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pdftool.core.plugin import BaseParams
+
+
+class CompressParams(BaseParams):
+    target_mb: float = Field(default=5.0, gt=0, description="Tamaño objetivo en MB.")
+    # "max" conserva el comportamiento actual y es el modo recomendado para
+    # el caso habitual: obtener el archivo más pequeño posible.
+    mode: Literal["max", "preserve"] = Field(
+        default="max",
+        description=(
+            "max: el archivo más pequeño posible (algunas páginas pueden perder "
+            "texto seleccionable); preserve: conserva texto, enlaces y anotaciones."
+        ),
+    )

pdftool/tools/compress/spec.py

@@ -0,0 +1,18 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.compress.logic import compress
+from pdftool.tools.compress.params import CompressParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="compress",
+            name="Comprimir PDF",
+            description="Reduce el tamaño de uno o varios PDFs a un objetivo en MB.",
+            category="Optimizar",
+            order=30,
+        ),
+        params=CompressParams,
+        run=compress,
+    )
+)

pdftool/tools/images2pdf/logic.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pymupdf
+
+from pdftool.core.atomic import atomic_output
+from pdftool.core.batch import noop_progress, run_batch
+from pdftool.core.errors import UserError
+from pdftool.core.naming import unique_path
+from pdftool.core.plugin import Progress, ToolResult
+from pdftool.tools.images2pdf.params import ImagesToPdfParams
+
+ALLOWED_SUFFIXES = {".jpg", ".jpeg", ".png"}
+# Una imagen de pocos KB puede declarar 60000×60000 px y agotar la memoria al
+# decodificarla; se rechaza leyendo solo la cabecera.
+MAX_IMAGE_PIXELS = 120_000_000
+
+# Marcadores JPEG SOFn con dimensiones (excluye DHT, JPG y DAC).
+_JPEG_SOF = {
+    0xC0,
+    0xC1,
+    0xC2,
+    0xC3,
+    0xC5,
+    0xC6,
+    0xC7,
+    0xC9,
+    0xCA,
+    0xCB,
+    0xCD,
+    0xCE,
+    0xCF,
+}
+
+
+def image_size(path: Path) -> tuple[int, int] | None:
+    """(ancho, alto) leídos de la cabecera PNG/JPEG, sin decodificar. None si
+    no se reconoce."""
+    with open(path, "rb") as f:
+        head = f.read(24)
+        if head[:8] == b"\x89PNG\r\n\x1a\n" and head[12:16] == b"IHDR":
+            return int.from_bytes(head[16:20], "big"), int.from_bytes(
+                head[20:24], "big"
+            )
+        if head[:2] != b"\xff\xd8":
+            return None
+        f.seek(2)
+        while True:
+            marker = f.read(2)
+            if len(marker) < 2 or marker[0] != 0xFF:
+                return None
+            if marker[1] in (0xD8, 0x01) or 0xD0 <= marker[1] <= 0xD7:
+                continue
+            length_bytes = f.read(2)
+            if len(length_bytes) < 2:
+                return None
+            length = int.from_bytes(length_bytes, "big")
+            if marker[1] in _JPEG_SOF:
+                data = f.read(5)
+                if len(data) < 5:
+                    return None
+                return int.from_bytes(data[3:5], "big"), int.from_bytes(
+                    data[1:3], "big"
+                )
+            f.seek(length - 2, 1)
+
+
+def _check_pixels(path: Path) -> None:
+    size = image_size(path)
+    if size is None:
+        return  # formato no reconocido: lo decidirá MuPDF
+    width, height = size
+    if width * height > MAX_IMAGE_PIXELS:
+        raise UserError(
+            f"La imagen es demasiado grande ({width}×{height} px). "
+            "Redúcela antes de convertirla."
+        )
+
+
+def output_path_for_images(input_path: Path, out_dir: Path | None = None) -> Path:
+    """`<imagen>.pdf` en el destino (o junto al original), sin pisar nada."""
+    p = Path(input_path)
+    carpeta = Path(out_dir) if out_dir is not None else p.parent
+    return unique_path(carpeta / f"{p.stem}.pdf")
+
+
+def _convert_one(
+    input_path: Path, progress: Progress, out_dir: Path | None = None
+) -> tuple[Path, str]:
+    """Convierte una imagen. Devuelve (salida, etiqueta); un error lanza."""
+    if input_path.suffix.lower() not in ALLOWED_SUFFIXES:
+        raise UserError("Formato no soportado (usa JPG o PNG).")
+    _check_pixels(input_path)
+    progress(0.0, "Convirtiendo imagen…")
+    out = output_path_for_images(input_path, out_dir)
+    # convert_to_pdf genera una página del tamaño exacto de la imagen.
+    with pymupdf.open(str(input_path)) as img:
+        pdf_bytes = img.convert_to_pdf()
+    with atomic_output(out) as temporary, pymupdf.open("pdf", pdf_bytes) as pdf:
+        pdf.save(str(temporary), garbage=4, deflate=True)
+    progress(1.0, "Listo")
+    return out, f"→ {out.name}"
+
+
+def images_to_pdf(
+    inputs: list[Path], params: ImagesToPdfParams, progress: Progress = noop_progress
+) -> ToolResult:
+    batch = run_batch(
+        inputs,
+        lambda path, scoped: _convert_one(path, scoped, params.output_dir),
+        progress,
+        all_failed="Ninguna imagen pudo convertirse.",
+    )
+    outputs, total = batch.outputs, batch.total
+
+    if total == 1:
+        return ToolResult(
+            outputs=outputs, summary=f"Imagen convertida → {outputs[0].name}"
+        )
+
+    progress(1.0, "Listo")
+    if len(outputs) == total:
+        summary = f"{total} imágenes convertidas"
+    else:
+        summary = f"{len(outputs)} de {total} imágenes convertidas"
+    return ToolResult(outputs=outputs, summary=summary, items=batch.items)

pdftool/tools/images2pdf/panel.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import flet as ft
+
+from pdftool.tools.images2pdf.params import ImagesToPdfParams
+from pdftool.tools.images2pdf.spec import SPEC
+from pdftool.ui.file_list import MultiFileToolPanel
+from pdftool.ui.registry import register
+
+
+@register
+class ImagesToPdfTool(MultiFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.PHOTO_LIBRARY
+    run_label = "Convertir"
+    run_icon = ft.Icons.PICTURE_AS_PDF
+    pick_label = "Añadir imágenes"
+    pick_icon = ft.Icons.ADD_PHOTO_ALTERNATE
+    show_thumbnails = True
+
+    def make_params(self):
+        return ImagesToPdfParams()

pdftool/tools/images2pdf/params.py

@@ -0,0 +1,6 @@
+from pdftool.core.plugin import BaseParams
+
+
+class ImagesToPdfParams(BaseParams):
+    """Sin parámetros: cada imagen (JPG/PNG) se convierte en su propio PDF de
+    una página del tamaño exacto de la imagen."""

pdftool/tools/images2pdf/spec.py

@@ -0,0 +1,19 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.images2pdf.logic import images_to_pdf
+from pdftool.tools.images2pdf.params import ImagesToPdfParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="images2pdf",
+            name="Imágenes a PDF",
+            description="Crea un PDF por cada imagen (JPG o PNG).",
+            category="Convertir",
+            order=40,
+        ),
+        params=ImagesToPdfParams,
+        run=images_to_pdf,
+        extensions=("jpg", "jpeg", "png"),
+    )
+)

pdftool/tools/merge/logic.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pymupdf
+
+from pdftool.core.atomic import atomic_output
+from pdftool.core.batch import noop_progress
+from pdftool.core.naming import unique_path
+from pdftool.core.plugin import Progress, ToolResult
+from pdftool.tools.merge.params import MergeParams
+
+
+def output_path_for_merge(
+    inputs: list[Path], name: str | None = None, out_dir: Path | None = None
+) -> Path:
+    """Salida junto al primer PDF (o en el destino); `name` custom o `<primero>_merged`.
+
+    Nunca pisa un archivo existente ni una de las entradas: si el nombre está
+    ocupado, se usa «nombre (1).pdf», «nombre (2).pdf»… La UI consulta esta
+    misma función para avisar del nombre final antes de ejecutar.
+
+    Si `out_dir` es None, la salida va junto al primer PDF.
+    """
+    first = Path(inputs[0])
+    base = name or f"{first.stem}_merged"
+    carpeta = Path(out_dir) if out_dir is not None else first.parent
+    return unique_path(carpeta / f"{base}.pdf", taken=inputs)
+
+
+def merge(
+    inputs: list[Path], params: MergeParams, progress: Progress = noop_progress
+) -> ToolResult:
+    if not inputs:
+        raise ValueError("inputs está vacío")
+
+    paths = [Path(p) for p in inputs]
+    for p in paths:
+        if not p.exists():
+            raise FileNotFoundError(p)
+
+    out = output_path_for_merge(paths, params.output_name, params.output_dir)
+    total = len(paths)
+    progress(0.0, f"Uniendo {total} PDFs…")
+
+    with atomic_output(out) as temporary, pymupdf.open() as out_doc:
+        for i, p in enumerate(paths):
+            with pymupdf.open(str(p)) as src:
+                out_doc.insert_pdf(src)
+            progress((i + 1) / (total + 1), f"Añadido {p.name}")
+        out_doc.save(str(temporary), garbage=4, deflate=True)
+
+    progress(1.0, f"Listo: {out.name}")
+    return ToolResult(outputs=[out], summary=f"{total} PDFs unidos → {out.name}")

pdftool/tools/merge/panel.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import flet as ft
+
+from pdftool.core.naming import parse_output_name
+from pdftool.tools.merge.logic import output_path_for_merge
+from pdftool.tools.merge.params import MergeParams
+from pdftool.tools.merge.spec import SPEC
+from pdftool.ui.file_list import MultiFileToolPanel
+from pdftool.ui.panel_base import OutputNameField
+from pdftool.ui.registry import register
+
+
+@register
+class MergeTool(MultiFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.MERGE
+    run_label = "Unir"
+    run_icon = ft.Icons.MERGE_TYPE
+    pick_label = "Añadir PDFs"
+    pick_icon = ft.Icons.UPLOAD_FILE
+    show_thumbnails = True
+    reorderable = True
+
+    def extra_controls(self) -> list[ft.Control]:
+        self._name_field = OutputNameField(resolve=self._resolve_output)
+        return [self._name_field]
+
+    def _resolve_output(self, base: str | None) -> Path | None:
+        """Ruta real que usaría el run, o None si aún no hay archivos."""
+        if not self._files:
+            return None
+        return output_path_for_merge(self._files, base, self._out_dir.value)
+
+    def on_inputs_changed(self) -> None:
+        self._name_field.refresh()
+
+    def on_output_dir_changed(self) -> None:
+        self._name_field.refresh()
+
+    def make_params(self):
+        return MergeParams(output_name=parse_output_name(self._name_field.value))

pdftool/tools/merge/params.py

@@ -0,0 +1,20 @@
+from pydantic import Field, field_validator
+
+from pdftool.core.naming import parse_output_name
+from pdftool.core.plugin import BaseParams
+
+
+class MergeParams(BaseParams):
+    """El orden lo decide la lista de inputs. `output_name` es la base del
+    archivo de salida (sin extensión); None → default."""
+
+    output_name: str | None = Field(
+        default=None,
+        description="Nombre del PDF unido, sin extensión (por defecto, automático).",
+    )
+
+    @field_validator("output_name")
+    @classmethod
+    def _sanitize(cls, value: str | None) -> str | None:
+        # Idempotente: la UI ya lo sanitiza para marcar el campo; la CLI no.
+        return parse_output_name(value)

pdftool/tools/merge/spec.py

@@ -0,0 +1,19 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.merge.logic import merge
+from pdftool.tools.merge.params import MergeParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="merge",
+            name="Unir PDFs",
+            description="Combina varios PDFs en uno solo, en el orden que elijas.",
+            category="Organizar",
+            order=10,
+        ),
+        params=MergeParams,
+        run=merge,
+        min_inputs=2,
+    )
+)

pdftool/tools/protect/logic.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pymupdf
+
+from pdftool.core.atomic import atomic_output
+from pdftool.core.batch import noop_progress, run_batch
+from pdftool.core.errors import UserError
+from pdftool.core.naming import output_path
+from pdftool.core.plugin import Progress, ToolResult
+from pdftool.tools.protect.params import ProtectParams
+
+
+def _output(input_path: Path, suffix: str, out_dir: Path | None = None) -> Path:
+    """Política de nombre de Proteger; la colisión la resuelve el helper."""
+    return output_path(input_path, suffix, out_dir=out_dir)
+
+
+def _protect_one(
+    input_path: Path, params: ProtectParams, progress: Progress
+) -> tuple[Path, str]:
+    """Procesa un archivo. Devuelve (salida, etiqueta); un error lanza."""
+    if params.mode == "protect":
+        progress(0.0, "Protegiendo PDF…")
+        out = _output(input_path, "protegido", params.output_dir)
+        with atomic_output(out) as temporary, pymupdf.open(str(input_path)) as doc:
+            if doc.needs_pass:
+                raise UserError(
+                    "El PDF ya está protegido; quítale la contraseña primero."
+                )
+            doc.save(
+                str(temporary),
+                encryption=pymupdf.PDF_ENCRYPT_AES_256,  # type: ignore[attr-defined]
+                owner_pw=params.password,
+                user_pw=params.password,
+                garbage=4,
+                deflate=True,
+            )
+        progress(1.0, "Listo")
+        return out, f"→ {out.name}"
+
+    # mode == "remove"
+    progress(0.0, "Quitando contraseña…")
+    out = _output(input_path, "sin_clave", params.output_dir)
+    with atomic_output(out) as temporary, pymupdf.open(str(input_path)) as doc:
+        if doc.needs_pass and not doc.authenticate(params.password):
+            raise UserError("Contraseña incorrecta.")
+        # garbage=4 descarta objetos sin referencias: si no, el PDF conserva el
+        # diccionario de cifrado viejo con los hashes de la contraseña quitada.
+        doc.save(
+            str(temporary),
+            encryption=pymupdf.PDF_ENCRYPT_NONE,  # type: ignore[attr-defined]
+            garbage=4,
+            deflate=True,
+        )
+    progress(1.0, "Listo")
+    return out, f"→ {out.name}"
+
+
+def protect(
+    inputs: list[Path], params: ProtectParams, progress: Progress = noop_progress
+) -> ToolResult:
+    batch = run_batch(
+        inputs,
+        lambda path, scoped: _protect_one(path, params, scoped),
+        progress,
+        all_failed="Ningún PDF pudo procesarse.",
+    )
+    outputs, total = batch.outputs, batch.total
+
+    if total == 1:
+        verb = "PDF protegido" if params.mode == "protect" else "Contraseña removida"
+        return ToolResult(outputs=outputs, summary=f"{verb} → {outputs[0].name}")
+
+    progress(1.0, "Listo")
+    if len(outputs) == total:
+        summary = (
+            f"{total} PDFs protegidos"
+            if params.mode == "protect"
+            else f"{total} contraseñas removidas"
+        )
+    else:
+        summary = f"{len(outputs)} de {total} PDFs procesados"
+    return ToolResult(outputs=outputs, summary=summary, items=batch.items)

pdftool/tools/protect/panel.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import flet as ft
+from pydantic import ValidationError
+
+from pdftool.core.plugin import ToolResult
+from pdftool.tools.protect.params import ProtectParams
+from pdftool.tools.protect.spec import SPEC
+from pdftool.ui.file_list import MultiFileToolPanel
+from pdftool.ui.panel_base import InvalidParams
+from pdftool.ui.registry import register
+
+
+@register
+class ProtectTool(MultiFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.LOCK
+    run_label = "Proteger"
+    run_icon = ft.Icons.LOCK
+    pick_label = "Añadir PDFs"
+
+    def extra_controls(self) -> list[ft.Control]:
+        self._mode_dd = ft.Dropdown(
+            label="Acción",
+            width=240,
+            value="protect",
+            options=[
+                ft.dropdown.Option("protect", "Proteger (poner contraseña)"),
+                ft.dropdown.Option("remove", "Quitar contraseña"),
+            ],
+        )
+        self._mode_dd.on_change = self._on_mode_change
+        self._pw_field = ft.TextField(
+            label="Contraseña", width=320, password=True, can_reveal_password=True
+        )
+        # Un error al teclear dejaría un PDF que nadie puede abrir.
+        self._confirm_field = ft.TextField(
+            label="Repetir contraseña",
+            width=320,
+            password=True,
+            can_reveal_password=True,
+            helper_text="Guárdala bien: sin ella no podrás abrir el PDF.",
+        )
+        return [self._mode_dd, self._pw_field, self._confirm_field]
+
+    def _on_mode_change(self, _e) -> None:
+        protecting = self._mode_dd.value == "protect"
+        self._pw_field.label = "Contraseña" if protecting else "Contraseña actual"
+        self._confirm_field.visible = protecting
+        self.run_btn.text = "Proteger" if protecting else "Quitar contraseña"
+        self.run_btn.icon = ft.Icons.LOCK if protecting else ft.Icons.LOCK_OPEN
+        self._page.update()
+
+    def on_result(self, result: ToolResult) -> None:
+        super().on_result(result)
+        # No dejar la contraseña escrita en un panel que se conserva al navegar.
+        self._pw_field.value = ""
+        self._confirm_field.value = ""
+
+    def make_params(self):
+        password = self._pw_field.value or ""
+        try:
+            params = ProtectParams(mode=self._mode_dd.value, password=password)
+        except (ValueError, ValidationError) as exc:
+            raise InvalidParams(
+                "Escribe una contraseña.", field=self._pw_field
+            ) from exc
+        if params.mode == "protect" and password != (self._confirm_field.value or ""):
+            raise InvalidParams(
+                "Las contraseñas no coinciden.", field=self._confirm_field
+            )
+        return params

pdftool/tools/protect/params.py

@@ -0,0 +1,18 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pdftool.core.plugin import BaseParams
+
+
+class ProtectParams(BaseParams):
+    mode: Literal["protect", "remove"] = Field(
+        default="protect",
+        description="protect: añade la contraseña; remove: la quita.",
+    )
+    # Secreto: la CLI nunca lo acepta como argumento (quedaría en el historial).
+    password: str = Field(
+        min_length=1,
+        description="Contraseña del PDF.",
+        json_schema_extra={"secret": True},
+    )

pdftool/tools/protect/spec.py

@@ -0,0 +1,18 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.protect.logic import protect
+from pdftool.tools.protect.params import ProtectParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="protect",
+            name="Proteger PDF",
+            description="Añade o quita la contraseña de uno o varios PDFs.",
+            category="Seguridad",
+            order=60,
+        ),
+        params=ProtectParams,
+        run=protect,
+    )
+)