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

pdftool/tools/split/logic.py

@@ -0,0 +1,139 @@
+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.errors import UserError
+from pdftool.core.naming import output_path
+from pdftool.core.plugin import Progress, ToolResult
+from pdftool.tools.split.params import SplitParams
+
+# Rango 1-indexed e inclusivo. None = extremo abierto (inicio o final del PDF).
+Range = tuple[int | None, int | None]
+
+
+def parse_ranges(spec: str) -> list[Range]:
+    """Parsea la sintaxis de rangos sin conocer el total de páginas.
+
+    Acepta (1-indexed, inclusivo), separados por comas:
+      ``N``    -> solo la página N            -> (N, N)
+      ``N-M``  -> de la N a la M              -> (N, M)
+      ``N-``   -> de la N hasta el final      -> (N, None)
+      ``-M``   -> del inicio hasta la M       -> (None, M)
+
+    Lanza ``ValueError`` si la sintaxis es inválida o el rango está invertido.
+    """
+    if not spec or not spec.strip():
+        raise UserError("Indica al menos un rango (ej: 1-3, 5, 8-)")
+
+    out: list[Range] = []
+    for raw in spec.split(","):
+        token = raw.strip()
+        if not token:  # tolera comas sobrantes ("1-3,")
+            continue
+        out.append(_parse_token(token))
+    if not out:
+        raise UserError("Indica al menos un rango (ej: 1-3, 5, 8-)")
+    return out
+
+
+def _parse_int(text: str) -> int:
+    if not text.isdigit():
+        raise UserError(
+            f"«{text}» no es un número de página válido. Usa por ejemplo 1-3, 5"
+        )
+    value = int(text)
+    if value < 1:
+        raise UserError("Las páginas empiezan en 1")
+    return value
+
+
+def _parse_token(token: str) -> Range:
+    if "-" not in token:
+        n = _parse_int(token)
+        return (n, n)
+
+    parts = token.split("-")
+    if len(parts) != 2:
+        raise UserError(f"«{token}» no es un rango válido. Usa por ejemplo 1-3, 5")
+    left, right = parts[0].strip(), parts[1].strip()
+
+    start = _parse_int(left) if left else None
+    end = _parse_int(right) if right else None
+    if not left and not right:
+        raise UserError(f"«{token}» no es un rango válido. Usa por ejemplo 1-3, 5")
+    if start is not None and end is not None and start > end:
+        raise UserError(
+            f"El rango «{token}» está al revés: escribe primero la página menor."
+        )
+    return (start, end)
+
+
+def resolve_ranges(parsed: list[Range], page_count: int) -> list[tuple[int, int]]:
+    """Rellena extremos abiertos con el total real y valida límites."""
+    resolved: list[tuple[int, int]] = []
+    for start, end in parsed:
+        s = 1 if start is None else start
+        e = page_count if end is None else end
+        if s > page_count or e > page_count:
+            raise UserError(f"El rango {s}-{e} excede el total de {page_count} páginas")
+        resolved.append((s, e))
+    return resolved
+
+
+def page_count(path: Path) -> int:
+    """Número de páginas de un PDF; lanza si no se puede abrir."""
+    with pymupdf.open(str(path)) as doc:
+        return doc.page_count
+
+
+def _label(start: int, end: int, width: int) -> str:
+    if start == end:
+        return f"p{start:0{width}d}"
+    return f"p{start:0{width}d}-{end:0{width}d}"
+
+
+def _ranges_for(params: SplitParams, page_count: int) -> list[tuple[int, int]]:
+    if params.mode == "single":
+        return [(i, i) for i in range(1, page_count + 1)]
+    if params.mode == "every":
+        return [
+            (s, min(s + params.every_n - 1, page_count))
+            for s in range(1, page_count + 1, params.every_n)
+        ]
+    return resolve_ranges(parse_ranges(params.ranges), page_count)
+
+
+def split(
+    inputs: list[Path], params: SplitParams, progress: Progress = noop_progress
+) -> ToolResult:
+    if not inputs:
+        raise ValueError("inputs está vacío")
+
+    src_path = Path(inputs[0])
+    if not src_path.exists():
+        raise FileNotFoundError(src_path)
+
+    outputs: list[Path] = []
+    with pymupdf.open(str(src_path)) as src:
+        page_count = src.page_count
+        ranges = _ranges_for(params, page_count)
+        width = len(str(page_count))
+        total = len(ranges)
+        progress(0.0, f"Dividiendo en {total} archivos…")
+
+        for i, (start, end) in enumerate(ranges):
+            out = output_path(
+                src_path, _label(start, end, width), out_dir=params.output_dir
+            )
+            with atomic_output(out) as temporary, pymupdf.open() as dst:
+                dst.insert_pdf(src, from_page=start - 1, to_page=end - 1)
+                dst.save(str(temporary), garbage=4, deflate=True)
+            outputs.append(out)
+            progress((i + 1) / total, f"Generado {out.name}")
+
+    progress(1.0, f"Listo: {total} archivos")
+    return ToolResult(outputs=outputs, summary=f"{src_path.name} → {total} archivos")

pdftool/tools/split/panel.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import flet as ft
+from pydantic import ValidationError
+
+from pdftool.core.errors import UserError
+from pdftool.tools.split.logic import page_count, parse_ranges, resolve_ranges
+from pdftool.tools.split.params import SplitParams
+from pdftool.tools.split.spec import SPEC
+from pdftool.ui.accessibility import HelpButton
+from pdftool.ui.panel_base import InvalidParams, SingleFileToolPanel
+from pdftool.ui.registry import register
+
+_RANGES_HELP = (
+    "Cómo escribir rangos:\n"
+    "  1-3    →  páginas 1 a la 3\n"
+    "  5      →  solo la página 5\n"
+    "  8-     →  de la página 8 hasta el final\n"
+    "  -4     →  del inicio hasta la página 4\n"
+    "Separa varios rangos con comas:\n"
+    "  1-3, 5, 8-"
+)
+
+
+@register
+class SplitTool(SingleFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.CONTENT_CUT
+    run_label = "Dividir"
+    run_icon = ft.Icons.CONTENT_CUT
+    pick_label = "Elegir PDF"
+
+    def extra_controls(self) -> list[ft.Control]:
+        self._pages = 0
+        self._ranges_help = HelpButton("Ayuda sobre rangos de páginas", _RANGES_HELP)
+        self._ranges_field = ft.TextField(
+            label="Rangos", hint_text="ej: 1-3, 5, 8-", width=240, disabled=False
+        )
+        # Sin label propio: la fila ya se lee «Cada [10] páginas».
+        self._every_field = ft.TextField(
+            value="10",
+            tooltip="Páginas por archivo",
+            width=160,
+            disabled=True,
+            keyboard_type=ft.KeyboardType.NUMBER,
+        )
+        self._mode = ft.RadioGroup(
+            value="ranges",
+            content=ft.Column(
+                [
+                    ft.Row(
+                        [
+                            ft.Radio(value="ranges", label="Por rangos"),
+                            self._ranges_field,
+                            self._ranges_help,
+                        ]
+                    ),
+                    self._ranges_help.detail,
+                    ft.Radio(value="single", label="Una página por archivo"),
+                    ft.Row(
+                        [
+                            ft.Radio(value="every", label="Cada"),
+                            self._every_field,
+                            ft.Text("páginas"),
+                        ]
+                    ),
+                ],
+                spacing=8,
+            ),
+        )
+        self._mode.on_change = self._on_mode_change
+        return [ft.Text("Cómo dividir:", weight=ft.FontWeight.W_500), self._mode]
+
+    def _on_mode_change(self, _e) -> None:
+        self._ranges_field.disabled = self._mode.value != "ranges"
+        self._every_field.disabled = self._mode.value != "every"
+        self._page.update()
+
+    def after_pick(self, path: Path) -> None:
+        # Se reinicia antes de leer: si el PDF no abre, los rangos no deben
+        # validarse contra las páginas del archivo anterior.
+        self._pages = 0
+        self._file_label.value = f"{path.name} · leyendo páginas…"
+
+        # Abrir un PDF grande o dañado puede tardar: se lee en segundo plano.
+        def on_done(count: int) -> None:
+            if self._file != path:  # el usuario ya eligió otro archivo
+                return
+            self._pages = count
+            self._file_label.value = f"{path.name} · {count} páginas"
+            self._sync_ready_state()
+            self._page.update()
+
+        def on_error(exc: Exception) -> None:
+            if self._file != path:
+                return
+            self._reject_pick(exc)
+            self._page.update()
+
+        self._ctx.run_job(
+            work=lambda _progress: page_count(path),
+            on_progress=lambda *_: None,
+            on_done=on_done,
+            on_error=on_error,
+        )
+
+    def can_run(self) -> bool:
+        return super().can_run() and self._pages > 0
+
+    def make_params(self):
+        try:
+            params = SplitParams(
+                mode=self._mode.value,
+                ranges=self._ranges_field.value or "",
+                every_n=int(self._every_field.value) if self._every_field.value else 1,
+            )
+        except (ValueError, ValidationError) as exc:
+            raise InvalidParams(
+                "Escribe un número de páginas mayor que 0.", field=self._every_field
+            ) from exc
+        if params.mode == "ranges":
+            # Valida sintaxis y límites antes de lanzar el job.
+            try:
+                resolve_ranges(parse_ranges(params.ranges), int(self._pages))
+            except UserError as exc:
+                raise InvalidParams(str(exc), field=self._ranges_field) from exc
+        return params

pdftool/tools/split/params.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from pdftool.core.plugin import BaseParams
+
+
+class SplitParams(BaseParams):
+    """Cómo dividir el PDF.
+
+    - ``ranges``: un PDF por cada rango de ``ranges`` (ej. "1-3, 5, 8-").
+    - ``single``: una página por archivo.
+    - ``every``: bloques de ``every_n`` páginas.
+    """
+
+    mode: Literal["ranges", "single", "every"] = Field(
+        default="ranges",
+        description="ranges: un PDF por rango; single: una página por archivo; "
+        "every: bloques de N páginas.",
+    )
+    ranges: str = Field(
+        default="", description='Rangos de páginas para mode=ranges, ej. "1-3, 5, 8-".'
+    )
+    every_n: int = Field(
+        default=1, ge=1, description="Páginas por archivo para mode=every."
+    )

pdftool/tools/split/spec.py

@@ -0,0 +1,19 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.split.logic import split
+from pdftool.tools.split.params import SplitParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="split",
+            name="Dividir PDF",
+            description="Separa un PDF en varios, por rangos o por páginas.",
+            category="Organizar",
+            order=20,
+        ),
+        params=SplitParams,
+        run=split,
+        max_inputs=1,
+    )
+)

pdftool/tools/watermark/logic.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import math
+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 output_path
+from pdftool.core.plugin import Progress, ToolResult
+from pdftool.tools.watermark.params import WatermarkParams
+
+_ANGLE = 45
+# Tope de sellos por página: el mosaico crece con el área de la página. Queda por
+# encima de un A0 con letra de 8 pt (~8000), así que solo actúa ante páginas
+# fuera de lo normal (hasta 14400 pt de lado).
+_MAX_STAMPS_PER_PAGE = 20_000
+
+
+def output_path_for_watermark(input_path: Path, out_dir: Path | None = None) -> Path:
+    """Política de nombre de Marca de agua; la colisión la resuelve el helper."""
+    return output_path(input_path, "marca", out_dir=out_dir)
+
+
+def _stamp_count(rect: pymupdf.Rect, sx: float, sy: float, text_w: float) -> int:
+    """Sellos que pondrá el mosaico (mismos límites que el bucle de `watermark`)."""
+    cols = math.ceil((rect.width + sx + text_w) / sx)
+    rows = math.ceil((rect.height + sy / 2) / sy)
+    return cols * rows
+
+
+def _grid_steps(
+    rect: pymupdf.Rect, step_x: float, step_y: float, text_w: float
+) -> tuple[float, float]:
+    """Separación del mosaico, ampliada si la página pediría demasiados sellos."""
+    stamps = _stamp_count(rect, step_x, step_y, text_w)
+    if stamps <= _MAX_STAMPS_PER_PAGE:
+        return step_x, step_y
+    scale = math.sqrt(stamps / _MAX_STAMPS_PER_PAGE)
+    while _stamp_count(rect, step_x * scale, step_y * scale, text_w) > (
+        _MAX_STAMPS_PER_PAGE
+    ):
+        scale *= 1.05
+    return step_x * scale, step_y * scale
+
+
+def _tile_page(
+    page: pymupdf.Page,
+    text: str,
+    params: WatermarkParams,
+    font: pymupdf.Font,
+    step_x: float,
+    step_y: float,
+    text_w: float,
+) -> None:
+    """Cubre la página con el texto girado `_ANGLE` grados en mosaico.
+
+    Cada sello gira sobre su propio punto de inicio. En vez de un insert_text
+    por sello (coste cuadrático: cada llamada reescribe el contenido de la
+    página), todos van en un único TextWriter con una sola rotación alrededor
+    del centro: cada sello se coloca en el punto que esa rotación lleva a su
+    posición final, con idéntico resultado.
+    """
+    rect = page.rect
+    sx, sy = _grid_steps(rect, step_x, step_y, text_w)
+    center = pymupdf.Point(rect.width / 2, rect.height / 2)
+    # `morph` gira en el sistema de PDF (y hacia arriba); en coordenadas de
+    # página la rotación inversa equivale a la misma matriz.
+    rot = pymupdf.Matrix(_ANGLE)
+    writer = pymupdf.TextWriter(rect, opacity=params.opacity, color=tuple(params.color))
+    y = sy / 2
+    while y < rect.height + sy:
+        x = -text_w
+        while x < rect.width + sx:
+            start = (pymupdf.Point(x, y) - center) * rot + center
+            writer.append(start, text, font=font, fontsize=params.font_size)
+            x += sx
+        y += sy
+    writer.write_text(page, morph=(center, rot), overlay=True)
+
+
+def watermark(
+    inputs: list[Path], params: WatermarkParams, progress: Progress = noop_progress
+) -> ToolResult:
+    if not inputs:
+        raise ValueError("inputs está vacío")
+    input_path = Path(inputs[0])
+    if not input_path.exists():
+        raise FileNotFoundError(input_path)
+
+    out = output_path_for_watermark(input_path, params.output_dir)
+    text = params.text
+    text_w = pymupdf.get_text_length(text, fontsize=params.font_size)
+    # Separación de la rejilla (mosaico): ancho del texto + holgura.
+    step_x = max(text_w + params.font_size * 2, params.font_size * 4)
+    step_y = params.font_size * 4
+
+    progress(0.0, "Aplicando marca de agua…")
+    font = pymupdf.Font("helv")
+    with atomic_output(out) as temporary, pymupdf.open(str(input_path)) as doc:
+        total = doc.page_count
+        for pno in range(total):
+            page = doc[pno]
+            _tile_page(page, text, params, font, step_x, step_y, text_w)
+            progress((pno + 1) / total, f"Página {pno + 1}/{total}")
+        doc.save(str(temporary), garbage=4, deflate=True)
+
+    progress(1.0, f"Listo: {out.name}")
+    return ToolResult(outputs=[out], summary=f"Marca '{text}' aplicada → {out.name}")

pdftool/tools/watermark/panel.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import flet as ft
+from pydantic import ValidationError
+
+from pdftool.tools.watermark.params import WatermarkParams
+from pdftool.tools.watermark.spec import SPEC
+from pdftool.ui.panel_base import InvalidParams, SingleFileToolPanel
+from pdftool.ui.registry import register
+
+_COLORS = {
+    "Gris": (0.5, 0.5, 0.5),
+    "Rojo": (0.85, 0.2, 0.2),
+    "Azul": (0.2, 0.4, 0.85),
+    "Negro": (0.0, 0.0, 0.0),
+}
+
+
+@register
+class WatermarkTool(SingleFileToolPanel):
+    spec = SPEC
+    icon = ft.Icons.BRANDING_WATERMARK
+    run_label = "Añadir marca de agua"
+    run_icon = ft.Icons.BRANDING_WATERMARK
+    pick_label = "Elegir PDF"
+
+    def extra_controls(self) -> list[ft.Control]:
+        self._text_field = ft.TextField(
+            label="Texto de la marca", value="CONFIDENCIAL", width=320
+        )
+        # En porcentaje: «15 %» se entiende mejor que «0.15».
+        self._opacity = ft.Slider(
+            min=5,
+            max=60,
+            value=15,
+            divisions=11,
+            label="{value} %",
+            width=320,
+        )
+        self._color_dd = ft.Dropdown(
+            label="Color",
+            width=160,
+            value="Gris",
+            options=[ft.dropdown.Option(name) for name in _COLORS],
+        )
+        self._size_field = ft.TextField(
+            label="Tamaño del texto (pt)",
+            value="40",
+            width=180,
+            keyboard_type=ft.KeyboardType.NUMBER,
+        )
+        return [
+            self._text_field,
+            ft.Row([self._color_dd, self._size_field]),
+            ft.Column([ft.Text("Opacidad"), self._opacity], spacing=0),
+        ]
+
+    def make_params(self):
+        try:
+            return WatermarkParams(
+                text=self._text_field.value or "",
+                opacity=float(self._opacity.value) / 100,
+                font_size=int(self._size_field.value),
+                color=_COLORS.get(self._color_dd.value, _COLORS["Gris"]),
+            )
+        except (ValueError, ValidationError) as exc:
+            raise InvalidParams("Revisa el texto, tamaño y opacidad.") from exc

pdftool/tools/watermark/params.py

@@ -0,0 +1,19 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from pdftool.core.plugin import BaseParams
+
+# Componente de color RGB.
+_Unit = Annotated[float, Field(ge=0, le=1)]
+
+
+class WatermarkParams(BaseParams):
+    text: str = Field(min_length=1, description="Texto de la marca de agua.")
+    opacity: float = Field(
+        default=0.15, gt=0, le=1, description="Opacidad, de 0 (excluido) a 1."
+    )
+    font_size: int = Field(default=40, gt=0, description="Tamaño de letra.")
+    color: tuple[_Unit, _Unit, _Unit] = Field(
+        default=(0.5, 0.5, 0.5), description="Color RGB, cada valor de 0 a 1."
+    )

pdftool/tools/watermark/spec.py

@@ -0,0 +1,19 @@
+from pdftool.core.plugin import ToolMeta, ToolSpec
+from pdftool.core.registry import register
+from pdftool.tools.watermark.logic import watermark
+from pdftool.tools.watermark.params import WatermarkParams
+
+SPEC = register(
+    ToolSpec(
+        meta=ToolMeta(
+            id="watermark",
+            name="Marca de agua",
+            description="Repite un texto en diagonal sobre todas las páginas.",
+            category="Editar",
+            order=50,
+        ),
+        params=WatermarkParams,
+        run=watermark,
+        max_inputs=1,
+    )
+)

pdftool/ui/accessibility.py

@@ -0,0 +1,44 @@
+"""Controles estándar con nombres accesibles y ayuda disponible al teclado."""
+
+import flet as ft
+
+
+def icon_content(icon, label: str) -> ft.Icon:
+    return ft.Icon(icon, size=24, semantics_label=label)
+
+
+class NamedIconButton(ft.IconButton):
+    def __init__(self, icon, label: str, **kwargs):
+        super().__init__(
+            content=icon_content(icon, label),
+            tooltip=label,
+            focus_color=ft.Colors.PRIMARY_CONTAINER,
+            **kwargs,
+        )
+
+
+class HelpButton(NamedIconButton):
+    """La ayuda se muestra al foco o al activar el botón, sin un diálogo."""
+
+    def __init__(self, label: str, message: str):
+        self.detail = ft.Text(
+            message,
+            size=12,
+            color=ft.Colors.ON_SURFACE_VARIANT,
+            visible=False,
+        )
+        super().__init__(ft.Icons.HELP_OUTLINE, label)
+        self.tooltip = message
+        self.on_focus = self._show
+        self.on_click = self._show
+        self.on_blur = self._hide
+
+    def _show(self, _e):
+        self.detail.visible = True
+        if self.page:
+            self.page.update()
+
+    def _hide(self, _e):
+        self.detail.visible = False
+        if self.page:
+            self.page.update()