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

pdftool/ui/file_list.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+
+import flet as ft
+
+from pdftool.core.plugin import ToolResult
+from pdftool.core.thumbnails import THUMBNAIL_HEIGHT_PX
+from pdftool.ui.accessibility import NamedIconButton
+from pdftool.ui.panel_base import WEB_MODE_MSG, BaseToolPanel
+from pdftool.ui.platform import open_file, shortcut_label
+from pdftool.ui.thumbnails import MISSING, ThumbnailTask, get_cached, load_async
+
+
+class MultiFileToolPanel(BaseToolPanel):
+    """Panel de lotes con lista, orden, resultados y miniaturas opcionales."""
+
+    show_thumbnails: bool = False  # solo tools donde el orden/identidad importa
+    # Flechas de orden solo donde el orden cambia el resultado (Unir): en las
+    # herramientas 1→1 sugieren algo que no ocurre.
+    reorderable: bool = False
+
+    def build_input(self, page) -> ft.Control:
+        previous_task = getattr(self, "_thumb_task", None)
+        if previous_task is not None:
+            previous_task.cancel()
+        self._files: list[Path] = []
+        self._results: list[str] = []  # etiqueta por archivo tras un run
+        self._failed: list[bool] = []  # fila cuyo archivo falló en el run
+        self._row_warnings: list[tuple[str, ...]] = []  # avisos por fila
+        self._row_paths: list[Path | None] = []  # ruta por fila exitosa tras un run
+        self._thumb_boxes: dict[str, ft.Container] = {}
+        self._thumb_task: ThumbnailTask | None = None
+        self._thumb_generation = getattr(self, "_thumb_generation", -1) + 1
+        self._picker.on_result = self._on_pick
+        self._clear_btn = ft.OutlinedButton(
+            "Limpiar lista",
+            icon=ft.Icons.CLEAR_ALL,
+            disabled=True,
+            on_click=self._clear_all,
+        )
+        self._pick_btn = ft.FilledTonalButton(
+            self.pick_label,
+            icon=self.pick_icon,
+            tooltip=f"{self.pick_label} ({shortcut_label('O')})",
+            on_click=lambda _e: self._picker.pick_files(
+                allow_multiple=True,
+                allowed_extensions=list(self.allowed_extensions),
+            ),
+        )
+        return ft.Row([self._pick_btn, self._clear_btn])
+
+    def _lock_inputs(self, locked: bool) -> None:
+        self._pick_btn.disabled = locked
+        if hasattr(self, "_file_list"):
+            self._refresh()
+
+    def build_body(self) -> ft.Control:
+        # La lista rellena el cuerpo y scrollea sola cuando no cabe; el footer
+        # (ejecutar, progreso, status) queda siempre visible.
+        # ListView construye solo las filas visibles: con cientos de archivos
+        # el scroll sigue siendo fluido.
+        self._file_list = ft.ListView(spacing=4, expand=True)
+        return self._file_list
+
+    @staticmethod
+    def _thumb_image(png: bytes) -> ft.Image:
+        return ft.Image(
+            src_base64=base64.b64encode(png).decode(),
+            height=THUMBNAIL_HEIGHT_PX,
+            fit=ft.ImageFit.CONTAIN,
+        )
+
+    def _thumb_control(self, path: Path) -> ft.Container:
+        cached = get_cached(path)
+        if cached is not MISSING and cached is not None:
+            content: ft.Control = self._thumb_image(cached)
+        else:
+            icon = (
+                ft.Icons.PICTURE_AS_PDF
+                if path.suffix.lower() == ".pdf"
+                else ft.Icons.IMAGE
+            )
+            content = ft.Icon(icon, size=28, color=ft.Colors.ON_SURFACE_VARIANT)
+        box = ft.Container(
+            content=content,
+            height=THUMBNAIL_HEIGHT_PX,
+            width=44,
+            alignment=ft.alignment.center,
+        )
+        self._thumb_boxes[str(path)] = box
+        return box
+
+    def _on_thumb_ready(self, path: Path, png: bytes | None) -> None:
+        # Llega desde el hilo del loader; si la fila ya no existe o el render
+        # falló (None), el placeholder/icono se queda como está.
+        box = self._thumb_boxes.get(str(path))
+        if box is None or png is None:
+            return
+        box.content = self._thumb_image(png)
+        # Sin page.update aquí: el loader llama a on_flush por lotes.
+
+    def _refresh(self) -> None:
+        if self._thumb_task is not None:
+            self._thumb_task.cancel()
+            self._thumb_task = None
+        self._thumb_generation += 1
+        generation = self._thumb_generation
+        self._thumb_boxes = {}
+        self._file_list.controls.clear()
+        for index, path in enumerate(self._files):
+            result = self._results[index] if index < len(self._results) else None
+            row_path = self._row_paths[index] if index < len(self._row_paths) else None
+            failed = index < len(self._failed) and self._failed[index]
+            warnings = (
+                self._row_warnings[index] if index < len(self._row_warnings) else ()
+            )
+            controls: list[ft.Control] = [ft.Text(f"{index + 1}.", width=28)]
+            if self.show_thumbnails:
+                controls.append(self._thumb_control(path))
+            controls += [
+                ft.Text(path.name, expand=True, overflow=ft.TextOverflow.ELLIPSIS),
+                ft.Text(
+                    result or "",
+                    size=14,
+                    no_wrap=True,
+                    color=ft.Colors.ERROR if failed else ft.Colors.ON_SURFACE_VARIANT,
+                ),
+            ]
+            if warnings:
+                text = " ".join(warnings)
+                controls.append(
+                    ft.Icon(
+                        ft.Icons.WARNING_AMBER_ROUNDED,
+                        size=20,
+                        color=ft.Colors.TERTIARY,
+                        tooltip=text,
+                        semantics_label=f"Aviso: {text}",
+                    )
+                )
+            controls += [
+                NamedIconButton(
+                    ft.Icons.OPEN_IN_NEW,
+                    f"Abrir resultado de {path.name}",
+                    visible=row_path is not None,
+                    on_click=lambda _e, p=row_path: open_file(p),
+                ),
+            ]
+            if self.reorderable:
+                controls += [
+                    NamedIconButton(
+                        ft.Icons.ARROW_UPWARD,
+                        f"Subir {path.name}",
+                        disabled=index == 0 or self._running,
+                        on_click=lambda _e, i=index: self._move(i, -1),
+                    ),
+                    NamedIconButton(
+                        ft.Icons.ARROW_DOWNWARD,
+                        f"Bajar {path.name}",
+                        disabled=index == len(self._files) - 1 or self._running,
+                        on_click=lambda _e, i=index: self._move(i, 1),
+                    ),
+                ]
+            controls += [
+                NamedIconButton(
+                    ft.Icons.CLOSE,
+                    f"Quitar {path.name} de la lista",
+                    disabled=self._running,
+                    on_click=lambda _e, i=index: self._remove(i),
+                ),
+            ]
+            self._file_list.controls.append(
+                ft.Row(controls, alignment=ft.MainAxisAlignment.SPACE_BETWEEN)
+            )
+        if self.show_thumbnails:
+            pending = [p for p in self._files if get_cached(p) is MISSING]
+            if pending:
+                self._thumb_task = load_async(
+                    pending,
+                    self._on_thumb_ready,
+                    is_current=lambda: self._thumb_generation == generation,
+                    on_flush=self._page.update,
+                )
+        self.on_inputs_changed()
+        self._sync_ready_state()
+        self._clear_btn.disabled = not self._files or self._running
+        n = len(self._files)
+        self._counter.value = (
+            "" if n == 0 else "1 archivo" if n == 1 else f"{n} archivos"
+        )
+        self._page.update()
+
+    def _clear_results(self) -> None:
+        self._results = []
+        self._row_paths = []
+        self._failed = []
+        self._row_warnings = []
+
+    def _move(self, index: int, delta: int) -> None:
+        new_index = index + delta
+        if 0 <= new_index < len(self._files):
+            self._invalidate_active_job()
+            self._files[index], self._files[new_index] = (
+                self._files[new_index],
+                self._files[index],
+            )
+            self._clear_results()
+            self._refresh()
+
+    def _remove(self, index: int) -> None:
+        self._invalidate_active_job()
+        self._files.pop(index)
+        self._clear_results()
+        self._refresh()
+
+    def _clear_all(self, _e) -> None:
+        self._invalidate_active_job()
+        removed = list(self._files)
+        self._files = []
+        self._clear_results()
+        self._clear_error()
+        self._set_status("")
+        self._hide_result_actions()
+        self._refresh()
+        if removed:
+            self._notify(
+                "Lista vaciada.",
+                action="Deshacer",
+                on_action=lambda _e: self._restore(removed),
+            )
+
+    def _restore(self, files: list[Path]) -> None:
+        """Deshace «Limpiar lista» si el usuario no añadió nada mientras."""
+        if self._files:
+            return
+        self._files = list(files)
+        self._refresh()
+
+    def _on_pick(self, e) -> None:
+        if not e.files:
+            return
+        self._invalidate_active_job()
+        added = 0
+        known = set(self._files)  # O(1) por archivo, también con miles
+        for f in e.files:
+            if not f.path:  # navegador (modo web): sin ruta local
+                continue
+            path = Path(f.path)
+            if path not in known:
+                known.add(path)
+                self._files.append(path)
+                added += 1
+        if added == 0 and e.files:
+            self._set_status(WEB_MODE_MSG)
+        else:
+            self._hide_result_actions()
+            self._set_status("")
+        self._clear_error()
+        self._clear_results()
+        self._refresh()
+
+    def on_result(self, result: ToolResult) -> None:
+        items = result.items or []
+        self._results = [item.message for item in items]
+        self._row_paths = [item.output_path if item.ok else None for item in items]
+        self._failed = [not item.ok for item in items]
+        self._row_warnings = [item.warnings for item in items]
+        self._refresh()
+
+    def collect_inputs(self) -> list[Path]:
+        return list(self._files)
+
+    def can_run(self) -> bool:
+        return len(self._files) >= self.min_files

pdftool/ui/logs.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import flet as ft
+
+from pdftool.core.logger import log_paths
+
+_EMPTY = "(registro vacío)\n"
+
+
+def _log_content() -> str:
+    chunks: list[str] = []
+    for p in log_paths():
+        try:
+            chunks.append(p.read_text(encoding="utf-8"))
+        except OSError:  # rotación entre exists() y read_text(): archivo ilegible
+            continue
+    return "".join(chunks) if chunks else _EMPTY
+
+
+LOG_LABEL = "Guardar informe de diagnóstico"
+
+
+def make_log_picker(
+    on_saved: Callable[[Path], None] | None = None,
+) -> ft.FilePicker:
+    """FilePicker de "guardar como" que escribe el log en la ruta elegida.
+
+    El llamador debe añadirlo a page.overlay (una sola vez). `on_saved` recibe
+    la ruta final para confirmar al usuario dónde quedó el informe.
+    """
+
+    def on_save(e: ft.FilePickerResultEvent) -> None:
+        if not e.path:  # diálogo cancelado (o modo web sin ruta)
+            return
+        target = Path(e.path)
+        if target.suffix.lower() != ".txt":
+            target = target.with_suffix(".txt")
+        target.write_text(_log_content(), encoding="utf-8")
+        if on_saved is not None:
+            on_saved(target)
+
+    return ft.FilePicker(on_result=on_save)
+
+
+def download_log_button(picker: ft.FilePicker) -> ft.Control:
+    """Botón del informe de diagnóstico: abre el diálogo de guardado."""
+    return ft.TextButton(
+        LOG_LABEL,
+        icon=ft.Icons.DOWNLOAD,
+        on_click=lambda _e: picker.save_file(
+            dialog_title=LOG_LABEL,
+            file_name="pdf-tool-log.txt",
+            allowed_extensions=["txt"],
+        ),
+    )

pdftool/ui/output_dir.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import flet as ft
+
+from pdftool.core.config import Settings, save_settings
+from pdftool.ui.accessibility import NamedIconButton
+
+_DEFAULT_LABEL = "Junto al original"
+
+
+def abbreviate_home(path: Path) -> str:
+    """Ruta legible: «~/Desktop» en vez de «/Users/quien/Desktop»."""
+    try:
+        rel = path.relative_to(Path.home())
+    except ValueError:
+        return str(path)
+    return "~" if rel == Path(".") else f"~/{rel}"
+
+
+class OutputDirField(ft.Row):
+    """Selector del destino de las salidas: junto al original o una carpeta.
+
+    El estado es global y vive en `Settings`; se persiste en cuanto cambia, no
+    al ejecutar. Si la carpeta guardada ya no existe (disco desconectado,
+    carpeta borrada), se vuelve al default en silencio.
+    """
+
+    def __init__(
+        self,
+        settings: Settings | None,
+        on_change: Callable[[], None] | None = None,
+        settings_path: Path | None = None,
+    ) -> None:
+        # Sin Settings real (p. ej. tests que no pasan ctx.settings), el
+        # widget usa una privada solo para no romper pero nunca persiste:
+        # de lo contrario `set_dir` escribiría en el settings.json real.
+        self._persist = settings is not None
+        self._settings = settings if settings is not None else Settings()
+        self._on_change = on_change
+        # Público a propósito: los tests lo redirigen a un tmp_path para no
+        # escribir en el settings.json real del usuario. None → el de la app.
+        self.settings_path = settings_path
+        self._dir = self._restore()
+
+        self.label = ft.Text(
+            _DEFAULT_LABEL, max_lines=1, overflow=ft.TextOverflow.ELLIPSIS, expand=True
+        )
+        self.change_btn = ft.TextButton(
+            "Cambiar…", icon=ft.Icons.FOLDER_OPEN, on_click=self._pick
+        )
+        self.reset_btn = NamedIconButton(
+            ft.Icons.UNDO,
+            "Volver a «junto al original»",
+            on_click=lambda _e: self.set_dir(None),
+        )
+        self._picker = ft.FilePicker(on_result=self._on_pick_result)
+
+        super().__init__(
+            [ft.Text("Guardar en:"), self.label, self.change_btn, self.reset_btn]
+        )
+        self._render()
+
+    # ---- estado ----
+    @property
+    def value(self) -> Path | None:
+        return self._dir
+
+    def set_dir(self, path: Path | None) -> None:
+        """Fija el destino, lo persiste y avisa al panel."""
+        self._dir = path
+        self._settings.output_dir = str(path) if path is not None else None
+        if self._persist:
+            save_settings(self._settings, self.settings_path)
+        self._render()
+        if self.page:
+            self.update()
+        if self._on_change:
+            self._on_change()
+
+    def attach(self, page) -> None:
+        """Registra el picker en el overlay una sola vez."""
+        if self._picker not in page.overlay:
+            page.overlay.append(self._picker)
+
+    def sync(self) -> None:
+        """Re-lee el destino de `Settings`. Lo llama el panel en cada render,
+        porque el widget sobrevive entre navegaciones y otro panel puede haber
+        cambiado el destino mientras tanto."""
+        self._dir = self._restore()
+        self._render()
+        if self.page:
+            self.update()
+
+    def destination_missing(self) -> bool:
+        """True si hay un destino elegido y ya no es una carpeta accesible."""
+        return self._dir is not None and not self._dir.is_dir()
+
+    # ---- interno ----
+    def _restore(self) -> Path | None:
+        guardado = self._settings.output_dir
+        if not guardado:
+            return None
+        path = Path(guardado)
+        if path.is_dir():
+            return path
+        # La carpeta ya no está: al default, sin molestar al usuario.
+        self._settings.output_dir = None
+        if self._persist:
+            save_settings(self._settings, self.settings_path)
+        return None
+
+    def _render(self) -> None:
+        self.label.value = (
+            _DEFAULT_LABEL if self._dir is None else abbreviate_home(self._dir)
+        )
+        self.label.tooltip = None if self._dir is None else str(self._dir)
+        self.reset_btn.visible = self._dir is not None
+
+    def _pick(self, _e) -> None:
+        self._picker.get_directory_path(dialog_title="Guardar las salidas en…")
+
+    def _on_pick_result(self, e) -> None:
+        if e.path:
+            self.set_dir(Path(e.path))