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

pdftool/ui/registry.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import importlib
+import logging
+import pkgutil
+
+from pdftool.core.plugin import PdfTool
+
+_REGISTRY: dict[str, type[PdfTool]] = {}
+# Todo lo registrado alguna vez, por módulo: `clear()` vacía el registro pero un
+# módulo ya importado no vuelve a ejecutar sus @register, así que `discover()`
+# los recupera de aquí.
+_SEEN: dict[str, list[type[PdfTool]]] = {}
+_log = logging.getLogger("pdftool.registry")
+
+
+def register(cls: type[PdfTool]) -> type[PdfTool]:
+    tool_id = cls.meta.id
+    current = _REGISTRY.get(tool_id)
+    if current is not None and current is not cls:
+        raise ValueError(
+            f"Id de herramienta duplicado: {tool_id!r} "
+            f"({current.__qualname__} y {cls.__qualname__})"
+        )
+    _REGISTRY[tool_id] = cls
+    seen = _SEEN.setdefault(cls.__module__, [])
+    if cls not in seen:
+        seen.append(cls)
+    return cls
+
+
+def clear() -> None:
+    _REGISTRY.clear()
+
+
+def get_tools() -> list[PdfTool]:
+    """Instancias ordenadas por `meta.order` y, a igualdad, por nombre."""
+    classes = sorted(_REGISTRY.values(), key=lambda c: (c.meta.order, c.meta.name))
+    return [cls() for cls in classes]
+
+
+def discover(package: str = "pdftool.tools") -> list[str]:
+    """Importa el `panel.py` de cada subpaquete de `package` para disparar @register.
+
+    Una herramienta que falla al importarse se registra en el log y se omite:
+    el resto de la app sigue funcionando. Devuelve los nombres que fallaron.
+    """
+    pkg = importlib.import_module(package)
+    failed: list[str] = []
+    for mod in pkgutil.iter_modules(pkg.__path__):
+        name = f"{package}.{mod.name}.panel"
+        try:
+            importlib.import_module(name)
+        except Exception:
+            _log.exception("No se pudo cargar la herramienta %s", mod.name)
+            failed.append(mod.name)
+    for module, classes in list(_SEEN.items()):
+        if module == package or module.startswith(f"{package}."):
+            for cls in classes:
+                _REGISTRY.setdefault(cls.meta.id, cls)
+    return failed

pdftool/ui/theme.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import flet as ft
+
+from pdftool.core.config import ThemeSetting
+
+SEED_COLOR = "#4F46E5"  # índigo moderno
+
+
+def build_theme() -> ft.Theme:
+    return ft.Theme(color_scheme_seed=SEED_COLOR)
+
+
+def resolve_mode(setting: str) -> ft.ThemeMode:
+    return {
+        "light": ft.ThemeMode.LIGHT,
+        "dark": ft.ThemeMode.DARK,
+    }.get(setting, ft.ThemeMode.SYSTEM)
+
+
+_NEXT_MODE: dict[str, ThemeSetting] = {
+    "system": "light",
+    "light": "dark",
+    "dark": "system",
+}
+
+
+def next_mode(setting: str) -> ThemeSetting:
+    """Cicla system -> light -> dark -> system para el toggle."""
+    return _NEXT_MODE.get(setting, "light")

pdftool/ui/thumbnails.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import os
+import threading
+import time
+from collections import OrderedDict
+from collections.abc import Callable, Sequence
+from concurrent.futures import Future, ThreadPoolExecutor, TimeoutError
+from pathlib import Path
+from typing import TypeVar
+
+from pdftool.core.thumbnails import THUMBNAIL_HEIGHT_PX, render_thumbnail
+
+MISSING = object()  # nunca se intentó (distinto de None = no renderizable)
+_CACHE_MAX = 512  # tope duro: ~2-5 MB de RAM; al superarlo expulsa el LRU
+_MAX_WORKERS = 2  # renderizar miniaturas es CPU/memoria intensivo
+
+_FLUSH_INTERVAL = 0.1  # s entre repintados de la UI mientras llegan miniaturas
+
+# Clave: ruta, página, alto, mtime y tamaño. Si el archivo cambia en disco, la
+# clave cambia y la miniatura antigua deja de servirse.
+_Key = tuple[str, int, int, int, int]
+_cache: OrderedDict[_Key, bytes | None] = OrderedDict()
+_lock = threading.Lock()
+_executor_lock = threading.Lock()
+_executor: ThreadPoolExecutor | None = ThreadPoolExecutor(
+    max_workers=_MAX_WORKERS, thread_name_prefix="pdftool-thumbnail"
+)
+
+
+class ThumbnailTask:
+    """Handle de una carga repartida entre los workers de miniaturas."""
+
+    def __init__(self, futures: list[Future]) -> None:
+        self._futures = futures
+
+    def cancel(self) -> bool:
+        """Cancela lo que aún no empezó; lo que ya empezó coopera vía is_current."""
+        return all([f.cancel() for f in self._futures])
+
+    def join(self, timeout: float | None = None) -> None:
+        """Espera a todos los trozos (para tests y cierre controlado)."""
+        for future in self._futures:
+            try:
+                future.result(timeout=timeout)
+            except TimeoutError:
+                return
+
+
+def _get_executor() -> ThreadPoolExecutor:
+    global _executor
+    with _executor_lock:
+        if _executor is None:
+            _executor = ThreadPoolExecutor(
+                max_workers=_MAX_WORKERS, thread_name_prefix="pdftool-thumbnail"
+            )
+        return _executor
+
+
+def shutdown_thumbnail_executor() -> None:
+    """Cancela tareas pendientes y libera los workers compartidos."""
+    global _executor
+    with _executor_lock:
+        executor = _executor
+        _executor = None
+    if executor is not None:
+        executor.shutdown(wait=False, cancel_futures=True)
+
+
+def _key(path: Path, page_index: int = 0) -> _Key:
+    try:
+        st = os.stat(path)
+        stamp, size = st.st_mtime_ns, st.st_size
+    except OSError:
+        stamp, size = -1, -1
+    return (str(path), page_index, THUMBNAIL_HEIGHT_PX, stamp, size)
+
+
+def get_cached(path: Path, page_index: int = 0):
+    """bytes | None (cacheado como no-renderizable) | MISSING (nunca intentado)."""
+    key = _key(path, page_index)
+    with _lock:
+        if key not in _cache:
+            return MISSING
+        _cache.move_to_end(key)
+        return _cache[key]
+
+
+def _store(key: _Key, value: bytes | None) -> None:
+    with _lock:
+        _cache[key] = value
+        _cache.move_to_end(key)
+        while len(_cache) > _CACHE_MAX:
+            _cache.popitem(last=False)
+
+
+Item = Path | tuple[Path, int]
+# El elemento que se pide es el que se devuelve a `on_ready` (ruta o par).
+T = TypeVar("T", bound=Item)
+
+
+def _split(item: Item) -> tuple[Path, int]:
+    return item if isinstance(item, tuple) else (item, 0)
+
+
+def load_async(
+    items: Sequence[T],
+    on_ready: Callable[[T, bytes | None], None],
+    is_current: Callable[[], bool],
+    *,
+    on_flush: Callable[[], None] | None = None,
+) -> ThumbnailTask:
+    """Renderiza `items` (rutas o pares (ruta, página)) y notifica cada uno.
+
+    El trabajo se reparte entre los workers de miniaturas. `on_ready` recibe el
+    mismo elemento que se pidió; `on_flush`, si se da, se llama como mucho cada
+    `_FLUSH_INTERVAL` segundos y al terminar cada trozo, para que la UI repinte
+    por lotes y no una vez por miniatura.
+
+    `is_current` es el token de generación del panel: si devuelve False la lista
+    cambió y el trabajo termina sin notificar (lo ya renderizado queda en caché).
+    """
+    chunks = [items[i::_MAX_WORKERS] for i in range(_MAX_WORKERS)]
+
+    def _target(chunk: Sequence[T]) -> None:
+        last_flush = time.monotonic()
+        pending = False
+        for item in chunk:
+            if not is_current():
+                return
+            path, page_index = _split(item)
+            value = get_cached(path, page_index)
+            if value is MISSING:
+                value = render_thumbnail(path, page_index)
+                _store(_key(path, page_index), value)
+            if not is_current():
+                return
+            on_ready(item, value)
+            pending = True
+            now = time.monotonic()
+            if on_flush is not None and now - last_flush >= _FLUSH_INTERVAL:
+                on_flush()
+                last_flush, pending = now, False
+        if on_flush is not None and pending and is_current():
+            on_flush()
+
+    executor = _get_executor()
+    return ThumbnailTask([executor.submit(_target, c) for c in chunks if c])