novel-downloader 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

novel_downloader/tui/screens/home.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.tui.screens.home
----------------------------------
-
-"""
-
-import asyncio
-import logging
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Horizontal, Vertical
-from textual.screen import Screen
-from textual.widgets import Button, Input, ProgressBar, RichLog, Select, Static
-
-from novel_downloader.config import ConfigAdapter
-from novel_downloader.core.factory import (
-    get_downloader,
-    get_exporter,
-    get_fetcher,
-    get_parser,
-)
-from novel_downloader.core.interfaces import FetcherProtocol
-from novel_downloader.models import LoginField
-from novel_downloader.tui.widgets.richlog_handler import RichLogHandler
-from novel_downloader.utils.i18n import t
-
-
-class HomeScreen(Screen):  # type: ignore[misc]
-    CSS_PATH = "../styles/home_layout.tcss"
-
-    def compose(self) -> ComposeResult:
-        yield Vertical(
-            self._make_title_bar(),
-            self._make_input_row(),
-            ProgressBar(id="prog", name="下载进度"),
-            Static("下载进度: 0/0 章", id="label-progress"),
-            RichLog(id="log", highlight=True, markup=False),
-            id="main-layout",
-        )
-
-    def on_mount(self) -> None:
-        log_widget = self.query_one("#log", RichLog)
-
-        self._log_handler = RichLogHandler(log_widget)
-        self._log_handler.setLevel(logging.INFO)
-        self._log_handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
-
-        self._setup_logging(self._log_handler)
-
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        if event.button.id == "exit":
-            logging.info("退出应用")
-            self.app.exit()
-
-        elif event.button.id == "settings":
-            logging.info("设置功能暂未实现")
-
-        elif event.button.id == "download":
-            site = self.query_one("#site", Select).value
-            ids = self.query_one("#book_ids", Input).value
-            if not site or not ids.strip():
-                logging.warning("请填写完整信息")
-                return
-            id_list = {x.strip() for x in ids.split(",") if x.strip()}
-            adapter = ConfigAdapter(config=self.app.config, site=str(site))
-            # asyncio.create_task(self._download(adapter, str(site), id_list))
-            self.run_worker(
-                self._download(adapter, str(site), id_list),
-                name="download",
-                group="downloads",
-                description="正在下载书籍...",
-            )
-
-    def _make_title_bar(self) -> Horizontal:
-        return Horizontal(
-            Static("小说下载器", id="title"),
-            Button("设置", id="settings"),
-            Button("关闭", id="exit"),
-            id="title-bar",
-        )
-
-    def _make_input_row(self) -> Horizontal:
-        return Horizontal(
-            Vertical(self._make_site_select(), classes="left"),
-            Vertical(
-                Input(placeholder="输入书籍ID (支持逗号分隔)", id="book_ids"),
-                classes="middle",
-            ),
-            Vertical(Button("下载", id="download"), classes="right"),
-            id="input-row",
-        )
-
-    def _make_site_select(self) -> Select:
-        return Select(
-            options=[
-                ("起点中文网", "qidian"),
-                ("笔趣阁", "biquge"),
-                ("铅笔小说", "qianbi"),
-                ("SF轻小说", "sfacg"),
-                ("ESJ Zone", "esjzone"),
-                ("百合会", "yamibo"),
-                ("哔哩轻小说", "linovelib"),
-            ],
-            prompt="选择站点",
-            value="qidian",
-            id="site",
-        )
-
-    async def _download(
-        self,
-        adapter: ConfigAdapter,
-        site: str,
-        book_ids: set[str],
-    ) -> None:
-        btn = self.query_one("#download", Button)
-        btn.disabled = True
-        try:
-            logging.info(f"下载请求: {site} | {book_ids}")
-            downloader_cfg = adapter.get_downloader_config()
-            fetcher_cfg = adapter.get_fetcher_config()
-            parser_cfg = adapter.get_parser_config()
-            exporter_cfg = adapter.get_exporter_config()
-
-            parser = get_parser(site, parser_cfg)
-            exporter = get_exporter(site, exporter_cfg)
-            self._setup_logging(self._log_handler)
-
-            async with get_fetcher(site, fetcher_cfg) as fetcher:
-                if downloader_cfg.login_required and not await fetcher.load_state():
-                    login_data = await self._prompt_login_fields(
-                        fetcher, fetcher.login_fields, downloader_cfg
-                    )
-                    if not await fetcher.login(**login_data):
-                        logging.info(t("download_login_failed"))
-                        return
-                    await fetcher.save_state()
-
-                downloader = get_downloader(
-                    fetcher=fetcher,
-                    parser=parser,
-                    site=site,
-                    config=downloader_cfg,
-                )
-
-                for book_id in book_ids:
-                    logging.info(t("download_downloading", book_id=book_id, site=site))
-                    await downloader.download(
-                        {"book_id": book_id},
-                        progress_hook=self._update_progress,
-                    )
-                    await asyncio.to_thread(exporter.export, book_id)
-
-                if downloader_cfg.login_required and fetcher.is_logged_in:
-                    await fetcher.save_state()
-        finally:
-            btn.disabled = False
-
-    async def _prompt_login_fields(
-        self,
-        fetcher: FetcherProtocol,
-        fields: list[LoginField],
-        cfg: Any = None,
-    ) -> dict[str, Any]:
-        """
-        Push a LoginScreen to collect all required fields,
-        then return the dict of values when the user submits.
-        """
-        # cfg_dict = asdict(cfg) if cfg else {}
-        # login_screen = LoginScreen(fields, cfg_dict)
-        # await self.app.push_screen(login_screen)
-        # await self.app.pop_screen()
-        return {}
-
-    def _setup_logging(self, handler: logging.Handler) -> None:
-        """
-        Attach the given handler to the root logger.
-        """
-        ft_logger = logging.getLogger("fontTools.ttLib.tables._p_o_s_t")
-        ft_logger.setLevel(logging.ERROR)
-        ft_logger.propagate = False
-
-        logger = logging.getLogger()
-        logger.setLevel(logging.INFO)
-
-        logger.handlers = [
-            h for h in logger.handlers if not isinstance(h, RichLogHandler)
-        ]
-        logger.addHandler(handler)
-
-    async def _update_progress(self, done: int, total: int) -> None:
-        prog = self.query_one("#prog", ProgressBar)
-        label = self.query_one("#label-progress", Static)
-
-        prog.update(total=total, progress=min(done, total))
-
-        label.update(f"下载进度: {done}/{total} 章")

novel_downloader/tui/screens/login.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.tui.screens.login
-----------------------------------
-
-"""
-
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Vertical
-from textual.screen import Screen
-from textual.widgets import Button, Input, Static
-
-from novel_downloader.models import LoginField
-
-
-class LoginScreen(Screen):  # type: ignore[misc]
-    """
-    A modal screen that gathers login fields, then fires LoginScreen.Submitted.
-    """
-
-    BINDINGS = [("escape", "app.pop_screen", "取消")]
-
-    def __init__(
-        self,
-        fields: list[LoginField],
-        cfg: dict[str, Any] | None = None,
-    ) -> None:
-        super().__init__()
-        self.fields = fields
-        self.cfg = cfg or {}
-
-    def compose(self) -> ComposeResult:
-        widgets = []
-        for field in self.fields:
-            # show label and optional description
-            widgets.append(Static(field.label))
-            if field.description:
-                widgets.append(Static(f"[i]{field.description}[/]"))
-
-            # pick input type
-            if field.type == "password":
-                inp = Input(
-                    placeholder=field.placeholder or "",
-                    password=True,
-                    id=field.name,
-                )
-            else:
-                inp = Input(
-                    placeholder=field.placeholder or "",
-                    id=field.name,
-                )
-
-            # pre-fill from config if present
-            existing = self.cfg.get(field.name, "").strip()
-            if existing:
-                inp.value = existing
-
-            widgets.append(inp)
-
-        # submit button at the end
-        widgets.append(Button("提交", id="submit"))
-        yield Vertical(*widgets, id="login-form")
-
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        if event.button.id == "submit":
-            data: dict[str, Any] = {}
-            for field in self.fields:
-                inp = self.query_one(f"#{field.name}", Input)
-                value = inp.value
-                if not value and self.cfg.get(field.name):
-                    value = self.cfg[field.name]
-                data[field.name] = value

novel_downloader/tui/styles/home_layout.tcss

@@ -1,79 +0,0 @@
-#main-layout {
-    grid-rows: 3 auto 1 auto 1fr;
-    grid-columns: 1fr;
-    grid-gutter: 1;
-    padding: 1;
-    height: 100%;
-}
-
-#title-bar {
-    height: 3;
-    layout: horizontal;
-    align: left middle;
-    padding: 0 1;
-    background: $boost;
-}
-
-#title {
-    width: 1fr;
-    content-align: left middle;
-}
-
-#settings,
-#exit {
-    width: 8;
-    padding: 0 1;
-}
-
-#input-row {
-    layout: horizontal;
-    padding: 1 0;
-    overflow-x: auto;
-}
-
-#site {
-    width: 20;
-    margin-right: 1;
-}
-
-#book_ids {
-    width: 1fr;
-    min-width: 0;
-    margin-right: 1;
-}
-
-#download {
-    width: 15;
-}
-
-#site,
-#book_ids,
-#download {
-    width: 100%;
-}
-
-Button#download {
-    border: round $accent;
-    padding: 0 1;
-}
-Button#download:hover {
-    background: $accent-lighten-3;
-    color: $text;
-}
-
-
-#prog {
-    height: 1;
-    color: $success;
-}
-
-#label {
-    content-align: left middle;
-    padding-left: 1;
-}
-
-#log {
-    border: round $primary;
-    padding: 1;
-    overflow-y: auto;
-}

novel_downloader/tui/widgets/richlog_handler.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.tui.widgets.richlog_handler
---------------------------------------------
-
-"""
-
-import logging
-from logging import LogRecord
-
-from textual.widgets import RichLog
-
-
-class RichLogHandler(logging.Handler):
-    def __init__(self, rich_log_widget: RichLog):
-        super().__init__()
-        self.rich_log_widget = rich_log_widget
-
-    def emit(self, record: LogRecord) -> None:
-        msg = self.format(record)
-        try:
-            self.rich_log_widget.write(msg)
-        except Exception:
-            self.handleError(record)

novel_downloader/utils/cache.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.cache
-----------------------------
-
-Provides decorators for caching function results,
-specifically optimized for configuration loading functions.
-"""
-
-from collections.abc import Callable
-from functools import lru_cache, wraps
-from typing import Any, TypeVar, cast
-
-T = TypeVar("T", bound=Callable[..., Any])
-
-
-def cached_load_config(func: T) -> T:
-    """
-    A decorator to cache the result of a config-loading function.
-    Uses LRU cache with maxsize=1.
-    """
-    cached = lru_cache(maxsize=1)(func)
-    wrapped = wraps(func)(cached)
-    return cast(T, wrapped)

novel_downloader/utils/fontocr/__init__.py

@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.fontocr
-------------------------------
-
-Utilities for font-based OCR, primarily used to decode custom font obfuscation
-
-Supports:
-- Font rendering and perceptual hash matching
-- PaddleOCR-based character recognition
-- Frequency-based scoring for ambiguous results
-- Debugging and font mapping persistence
-
-Exposes the selected OCR engine version via `FontOCR`.
-"""
-
-__all__ = ["FontOCR"]
-__version__ = "3.0"
-
-# from .ocr_v1 import FontOCRV1 as FontOCR
-# from .ocr_v2 import FontOCRV2 as FontOCR
-from .ocr_v3 import FontOCRV3 as FontOCR

novel_downloader/utils/fontocr/hash_store.py

@@ -1,280 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.fontocr.hash_store
------------------------------------------
-
-Manage a small collection of image perceptual hashes and their labels.
-Supports loading/saving to .json or .npy, and basic CRUD + search.
-"""
-
-import heapq
-import json
-import logging
-from collections.abc import Callable
-from pathlib import Path
-
-from PIL import Image
-
-from ..constants import DATA_DIR
-from .hash_utils import HASH_DISTANCE_THRESHOLD, fast_hamming_distance, phash
-
-logger = logging.getLogger(__name__)
-HASH_STORE_FILE = DATA_DIR / "image_hashes.json"
-
-
-class _BKNode:
-    """
-    A node in a Burkhard-Keller tree (BK-Tree) for distance search.
-    Stores one value and a dict of children keyed by distance.
-    """
-
-    __slots__ = ("value", "children")
-
-    def __init__(self, value: int):
-        self.value = value
-        self.children: dict[int, _BKNode] = {}
-
-    def add(self, h: int, dist_fn: Callable[[int, int], int]) -> None:
-        d = dist_fn(h, self.value)
-        child = self.children.get(d)
-        if child is not None:
-            child.add(h, dist_fn)
-        else:
-            self.children[d] = _BKNode(h)
-
-    def query(
-        self,
-        target: int,
-        threshold: int,
-        dist_fn: Callable[[int, int], int],
-    ) -> list[tuple[int, int]]:
-        """
-        Recursively collect (value, dist) pairs within threshold.
-        """
-        d0 = dist_fn(target, self.value)
-        matches: list[tuple[int, int]] = []
-        if d0 <= threshold:
-            matches.append((self.value, d0))
-        # Only children whose edge-dist \in [d0-threshold, d0+threshold]
-        lower, upper = d0 - threshold, d0 + threshold
-        for edge, child in self.children.items():
-            if lower <= edge <= upper:
-                matches.extend(child.query(target, threshold, dist_fn))
-        return matches
-
-
-class ImageHashStore:
-    """
-    Store and manage image hashes grouped by label, with a BK-Tree index.
-
-    :param path: file path for persistence (".json" or ".npy")
-    :param auto_save: if True, every modification automatically calls save()
-    :param hash_func: function to compute hash from PIL.Image
-    :param ham_dist: function to compute Hamming distance between two hashes
-    """
-
-    def __init__(
-        self,
-        path: str | Path = HASH_STORE_FILE,
-        auto_save: bool = False,
-        hash_func: Callable[[Image.Image], int] = phash,
-        ham_dist: Callable[[int, int], int] = fast_hamming_distance,
-        threshold: int = HASH_DISTANCE_THRESHOLD,
-    ) -> None:
-        self._path = Path(path)
-        self._auto = auto_save
-        self._hf = hash_func
-        self._hd = ham_dist
-        self._th = threshold
-
-        # label -> set of hashes
-        self._hash: dict[str, set[int]] = {}
-        # hash -> list of labels (for reverse lookup)
-        self._hash_to_labels: dict[int, list[str]] = {}
-        # root of BK-Tree (or None if empty)
-        self._bk_root: _BKNode | None = None
-
-        self.load()
-
-    def load(self) -> None:
-        """Load store from disk and rebuild BK-Tree index."""
-        if not self._path.exists():
-            self._hash.clear()
-            logger.debug(
-                "[ImageHashStore] No file found at %s, starting empty.", self._path
-            )
-            return
-
-        txt = self._path.read_text(encoding="utf-8")
-        obj = json.loads(txt) or {}
-        self._hash = {lbl: set(obj.get(lbl, [])) for lbl in obj}
-
-        # rebuild reverse map and BK-Tree
-        self._hash_to_labels.clear()
-        for lbl, hs in self._hash.items():
-            for h in hs:
-                self._hash_to_labels.setdefault(h, []).append(lbl)
-        logger.debug(
-            "[ImageHashStore] Loaded hash store from %s with %d hashes",
-            self._path,
-            sum(len(v) for v in self._hash.values()),
-        )
-
-        self._build_index()
-
-    def _build_index(self) -> None:
-        """Construct a BK-Tree over all stored hashes."""
-        self._bk_root = None
-        for h in self._hash_to_labels:
-            if self._bk_root is None:
-                self._bk_root = _BKNode(h)
-            else:
-                self._bk_root.add(h, self._hd)
-        logger.debug(
-            "[ImageHashStore] BK-tree index built with %d unique hashes",
-            len(self._hash_to_labels),
-        )
-
-    def save(self) -> None:
-        """Persist current store to disk."""
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        data = {lbl: list(s) for lbl, s in self._hash.items()}
-        txt = json.dumps(data, ensure_ascii=False, indent=2)
-        self._path.write_text(txt, encoding="utf-8")
-        logger.debug("[ImageHashStore] Saved hash store to %s", self._path)
-
-    def _maybe_save(self) -> None:
-        if self._auto:
-            self.save()
-
-    def add_image(self, img_path: str | Path, label: str) -> int:
-        """
-        Compute hash for the given image and add it under `label`.
-        Updates BK-Tree index incrementally.
-        """
-        img = Image.open(img_path).convert("L")
-        h = self._hf(img)
-        self._hash.setdefault(label, set()).add(h)
-        self._hash_to_labels.setdefault(h, []).append(label)
-        # insert into BK-Tree
-        if self._bk_root is None:
-            self._bk_root = _BKNode(h)
-        else:
-            self._bk_root.add(h, self._hd)
-        logger.debug("[ImageHashStore] Added hash %d under label '%s'", h, label)
-        self._maybe_save()
-        return h
-
-    def add_from_map(self, map_path: str | Path) -> None:
-        """
-        Load a JSON file of the form { "image_path": "label", ... }
-        and add each entry.
-        """
-        map_path = Path(map_path)
-        text = map_path.read_text(encoding="utf-8")
-        mapping = json.loads(text)
-        for rel_img_path, lbl in mapping.items():
-            img_path = (map_path.parent / rel_img_path).resolve()
-            try:
-                self.add_image(img_path, lbl)
-            except Exception as e:
-                logger.warning(
-                    "[ImageHashStore] Failed to add image '%s': %s", img_path, str(e)
-                )
-                continue
-
-    def labels(self) -> list[str]:
-        """Return a sorted list of all labels in the store."""
-        return sorted(self._hash.keys())
-
-    def hashes(self, label: str) -> set[int]:
-        """Return the set of hashes for a given `label` (empty set if none)."""
-        return set(self._hash.get(label, ()))
-
-    def remove_label(self, label: str) -> None:
-        """Remove all hashes associated with `label`."""
-        if label in self._hash:
-            del self._hash[label]
-            logger.debug("[ImageHashStore] Removed label '%s'", label)
-            self._maybe_save()
-
-    def remove_hash(self, label: str, this: int | str | Path) -> bool:
-        """
-        Remove a specific hash under `label`.
-        `this` can be:
-         - an integer hash
-         - a Path (image file) -> will compute its hash then remove
-        Returns True if something was removed.
-        """
-        if label not in self._hash:
-            return False
-
-        h = None
-        if isinstance(this, (str | Path)):
-            try:
-                img = Image.open(this).convert("L")
-                h = self._hf(img)
-            except Exception as e:
-                logger.warning(
-                    "[ImageHashStore] Could not open image '%s': %s", this, str(e)
-                )
-                return False
-        else:
-            h = int(this)
-
-        if h in self._hash[label]:
-            self._hash[label].remove(h)
-            logger.debug("[ImageHashStore] Removed hash %d from label '%s'", h, label)
-            self._maybe_save()
-            return True
-        return False
-
-    def query(
-        self,
-        target: int | str | Path | Image.Image,
-        k: int = 1,
-        threshold: int | None = None,
-    ) -> list[tuple[str, float]]:
-        """
-        Find up to `k` distinct labels whose stored hashes are most similar
-        to `target` within `threshold`. Returns a list of (label, score),
-        sorted by descending score. Each label appears at most once.
-
-        :param target: Image path / int hash / PIL.Image
-        :param k: number of labels to return (default=1)
-        :param threshold: Hamming distance cutoff (default=self._th)
-        """
-        if threshold is None:
-            threshold = self._th
-
-        # compute target hash
-        if isinstance(target, Image.Image):
-            img = target.convert("L")
-            thash = self._hf(img)
-        elif isinstance(target, (str | Path)):
-            img = Image.open(target).convert("L")
-            thash = self._hf(img)
-        else:
-            thash = int(target)
-
-        if self._bk_root is None:
-            return []
-
-        # find all (hash,dist) within threshold
-        matches = self._bk_root.query(thash, threshold, self._hd)
-
-        # collapse to one best dist per label
-        best_per_label: dict[str, float] = {}
-        h2l = self._hash_to_labels
-        for h, dist in matches:
-            for lbl in h2l.get(h, ()):
-                score = 1.0 - dist / threshold
-                prev = best_per_label.get(lbl)
-                if prev is None or score > prev:
-                    best_per_label[lbl] = score
-
-        top_k = heapq.nsmallest(k, best_per_label.items(), key=lambda x: x[1])
-        return top_k
-
-
-img_hash_store = ImageHashStore()