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

novel_downloader/core/parsers/qidian/chapter_encrypted.py

@@ -11,16 +11,14 @@ from __future__ import annotations
 
 import json
 import logging
-from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import tinycss2
 from lxml import html
 
 from novel_downloader.models import ChapterDict
-from novel_downloader.utils.network import download_font_file
-from novel_downloader.utils.text_utils import (
-    apply_font_mapping,
+from novel_downloader.utils import (
+    download,
     truncate_half_lines,
 )
 
@@ -70,10 +68,9 @@ def parse_encrypted_chapter(
             )
             return None
 
-        debug_base_dir: Path | None = None
-        if parser._font_debug_dir:
-            debug_base_dir = parser._font_debug_dir / chapter_id
-            debug_base_dir.mkdir(parents=True, exist_ok=True)
+        debug_dir = parser._debug_dir / "font_debug" / "qidian" / chapter_id
+        if parser.save_font_debug:
+            debug_dir.mkdir(parents=True, exist_ok=True)
 
         css_str = chapter_info["css"]
         randomFont_str = chapter_info["randomFont"]
@@ -98,8 +95,10 @@ def parse_encrypted_chapter(
         rand_path.parent.mkdir(parents=True, exist_ok=True)
         rand_path.write_bytes(bytes(rf["data"]))
 
-        fixed_path = download_font_file(
-            url=fixedFontWoff2_url, target_folder=parser._fixed_font_dir
+        fixed_path = download(
+            url=fixedFontWoff2_url,
+            target_dir=parser._fixed_font_dir,
+            stream=True,
         )
         if fixed_path is None:
             raise ValueError("fixed_path is None: failed to download font")
@@ -125,16 +124,16 @@ def parse_encrypted_chapter(
                     return None
             main_paragraphs = extract_paragraphs_recursively(raw_html, chapter_id)
 
-        if debug_base_dir:
-            main_paragraphs_path = debug_base_dir / "main_paragraphs_debug.json"
+        if parser.save_font_debug:
+            main_paragraphs_path = debug_dir / "main_paragraphs_debug.json"
             main_paragraphs_path.write_text(
                 json.dumps(main_paragraphs, ensure_ascii=False, indent=2),
                 encoding="utf-8",
             )
 
         paragraphs_rules = parse_rule(css_str)
-        if debug_base_dir:
-            paragraphs_rules_path = debug_base_dir / "paragraphs_rules_debug.json"
+        if parser.save_font_debug:
+            paragraphs_rules_path = debug_dir / "paragraphs_rules_debug.json"
             paragraphs_rules_path.write_text(
                 json.dumps(paragraphs_rules, ensure_ascii=False, indent=2),
                 encoding="utf-8",
@@ -146,16 +145,16 @@ def parse_encrypted_chapter(
             paragraphs_rules,
             end_number,
         )
-        if debug_base_dir:
-            paragraphs_str_path = debug_base_dir / f"{chapter_id}_debug.txt"
+        if parser.save_font_debug:
+            paragraphs_str_path = debug_dir / f"{chapter_id}_debug.txt"
             paragraphs_str_path.write_text(paragraphs_str, encoding="utf-8")
 
         # Run OCR + fallback mapping
         char_set = {c for c in paragraphs_str if c not in {" ", "\n", "\u3000"}}
         refl_set = set(refl_list)
         char_set = char_set - refl_set
-        if debug_base_dir:
-            char_sets_path = debug_base_dir / "char_set_debug.txt"
+        if parser.save_font_debug:
+            char_sets_path = debug_dir / "char_set_debug.txt"
             temp = f"char_set:\n{char_set}\n\nrefl_set:\n{refl_set}"
             char_sets_path.write_text(
                 temp,
@@ -169,15 +168,18 @@ def parse_encrypted_chapter(
             refl_set=refl_set,
             chapter_id=chapter_id,
         )
-        if debug_base_dir:
-            mapping_json_path = debug_base_dir / "font_mapping.json"
+        if parser.save_font_debug:
+            mapping_json_path = debug_dir / "font_mapping.json"
             mapping_json_path.write_text(
                 json.dumps(mapping_result, ensure_ascii=False, indent=2),
                 encoding="utf-8",
             )
 
         # Reconstruct final readable text
-        original_text = apply_font_mapping(paragraphs_str, mapping_result)
+        original_text = parser._font_ocr.apply_font_mapping(
+            text=paragraphs_str,
+            font_map=mapping_result,
+        )
 
         final_paragraphs_str = "\n\n".join(
             line.strip() for line in original_text.splitlines() if line.strip()

novel_downloader/core/parsers/qidian/chapter_normal.py

@@ -15,7 +15,7 @@ from typing import TYPE_CHECKING
 from lxml import html
 
 from novel_downloader.models import ChapterDict
-from novel_downloader.utils.text_utils import truncate_half_lines
+from novel_downloader.utils import truncate_half_lines
 
 from .utils import (
     extract_chapter_info,

novel_downloader/core/parsers/qidian/main_parser.py

@@ -13,9 +13,10 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from novel_downloader.core.parsers.base import BaseParser
+from novel_downloader.core.parsers.registry import register_parser
 from novel_downloader.models import ChapterDict, ParserConfig
+from novel_downloader.utils import find_cookie_value
 from novel_downloader.utils.constants import DATA_DIR
-from novel_downloader.utils.cookies import find_cookie_value
 
 from .book_info_parser import parse_book_info
 from .chapter_router import parse_chapter
@@ -27,6 +28,10 @@ if TYPE_CHECKING:
     from novel_downloader.utils.fontocr import FontOCR
 
 
+@register_parser(
+    site_keys=["qidian", "qd"],
+    backends=["session", "browser"],
+)
 class QidianParser(BaseParser):
     """
     Parser for Qidian site.
@@ -47,11 +52,10 @@ class QidianParser(BaseParser):
         # Extract and store parser flags from config
         self._use_truncation = config.use_truncation
         self._decode_font: bool = config.decode_font
-        self._save_font_debug: bool = config.save_font_debug
 
         self._fixed_font_dir: Path = self._base_cache_dir / "fixed_fonts"
         self._fixed_font_dir.mkdir(parents=True, exist_ok=True)
-        self._font_debug_dir: Path | None = None
+        self._debug_dir: Path = Path.cwd() / "debug"
 
         state_files = [
             DATA_DIR / "qidian" / "browser_state.cookies",
@@ -80,8 +84,6 @@ class QidianParser(BaseParser):
                     vec_weight=config.vec_weight,
                     font_debug=config.save_font_debug,
                 )
-                self._font_debug_dir = self._base_cache_dir / "qidian" / "font_debug"
-                self._font_debug_dir.mkdir(parents=True, exist_ok=True)
 
     def parse_book_info(
         self,
@@ -121,19 +123,6 @@ class QidianParser(BaseParser):
         """
         return is_encrypted(html_str)
 
-    def _init_cache_folders(self) -> None:
-        """
-        Prepare cache folders for plain/encrypted HTML and font debug data.
-        Folders are only created if corresponding debug/save flags are enabled.
-        """
-        base = self._base_cache_dir
-
-        # Font debug folder
-        if self._save_font_debug and self.book_id:
-            self._font_debug_dir = base / self.book_id / "font_debug"
-            self._font_debug_dir.mkdir(parents=True, exist_ok=True)
-        else:
-            self._font_debug_dir = None
-
-    def _on_book_id_set(self) -> None:
-        self._init_cache_folders()
+    @property
+    def save_font_debug(self) -> bool:
+        return self._config.save_font_debug

novel_downloader/core/parsers/qidian/utils/__init__.py

@@ -5,17 +5,6 @@ novel_downloader.core.parsers.qidian.utils
 
 """
 
-from .helpers import (
-    can_view_chapter,
-    extract_chapter_info,
-    find_ssr_page_context,
-    is_duplicated,
-    is_encrypted,
-    is_restricted_page,
-    vip_status,
-)
-from .node_decryptor import QidianNodeDecryptor, get_decryptor
-
 __all__ = [
     "find_ssr_page_context",
     "extract_chapter_info",
@@ -27,3 +16,14 @@ __all__ = [
     "QidianNodeDecryptor",
     "get_decryptor",
 ]
+
+from .helpers import (
+    can_view_chapter,
+    extract_chapter_info,
+    find_ssr_page_context,
+    is_duplicated,
+    is_encrypted,
+    is_restricted_page,
+    vip_status,
+)
+from .node_decryptor import QidianNodeDecryptor, get_decryptor

novel_downloader/core/parsers/qidian/utils/decryptor_fetcher.py

@@ -9,6 +9,11 @@ GitHub releases.
 
 from __future__ import annotations
 
+__all__ = [
+    "ensure_decryptor",
+    "RELEASE_VERSION",
+]
+
 import hashlib
 import platform
 import stat
@@ -137,9 +142,3 @@ def _make_executable(p: Path) -> None:
         p.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
     except PermissionError:
         pass
-
-
-__all__ = [
-    "ensure_decryptor",
-    "RELEASE_VERSION",
-]

novel_downloader/core/parsers/qidian/utils/node_decryptor.py

@@ -80,10 +80,10 @@ class QidianNodeDecryptor:
 
             # 3) Download the Fock JS module from Qidian CDN if missing
             if not self.QIDIAN_FOCK_JS_PATH.exists():
-                from novel_downloader.utils.network import download_js_file
+                from novel_downloader.utils.network import download
 
                 try:
-                    download_js_file(
+                    download(
                         self.QIDIAN_FOCK_JS_URL,
                         self.script_dir,
                         on_exist="overwrite",

novel_downloader/core/parsers/registry.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.registry
+--------------------------------------
+
+"""
+
+__all__ = ["register_parser", "get_parser"]
+
+from collections.abc import Callable, Sequence
+from typing import TypeVar
+
+from novel_downloader.core.interfaces import ParserProtocol
+from novel_downloader.models import ParserConfig
+
+ParserBuilder = Callable[[ParserConfig], ParserProtocol]
+
+P = TypeVar("P", bound=ParserProtocol)
+_PARSER_MAP: dict[str, dict[str, ParserBuilder]] = {}
+
+
+def register_parser(
+    site_keys: Sequence[str],
+    backends: Sequence[str],
+) -> Callable[[type[P]], type[P]]:
+    """
+    Decorator to register a parser class under given keys.
+
+    :param site_keys: Sequence of site identifiers
+    :param backends:  Sequence of backend types
+    :return: A class decorator that populates _PARSER_MAP.
+    """
+
+    def decorator(cls: type[P]) -> type[P]:
+        for site in site_keys:
+            site_lower = site.lower()
+            bucket = _PARSER_MAP.setdefault(site_lower, {})
+            for backend in backends:
+                bucket[backend] = cls
+        return cls
+
+    return decorator
+
+
+def get_parser(site: str, config: ParserConfig) -> ParserProtocol:
+    """
+    Returns a site-specific parser instance.
+
+    :param site: Site name (e.g., 'qidian')
+    :param config: Configuration for the parser
+    :return: An instance of a parser class
+    """
+    site_key = site.lower()
+    try:
+        backend_map = _PARSER_MAP[site_key]
+    except KeyError as err:
+        raise ValueError(f"Unsupported site: {site!r}") from err
+
+    mode = config.mode
+    try:
+        parser_cls = backend_map[mode]
+    except KeyError as err:
+        raise ValueError(
+            f"Unsupported parser mode {mode!r} for site {site!r}. "
+            f"Available modes: {list(backend_map)}"
+        ) from err
+
+    return parser_cls(config)

novel_downloader/core/parsers/{sfacg/main_parser.py → sfacg.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.parsers.sfacg.main_parser
------------------------------------------------
+novel_downloader.core.parsers.sfacg
+-----------------------------------
 
 """
 
@@ -10,9 +10,14 @@ from typing import Any
 from lxml import html
 
 from novel_downloader.core.parsers.base import BaseParser
+from novel_downloader.core.parsers.registry import register_parser
 from novel_downloader.models import ChapterDict
 
 
+@register_parser(
+    site_keys=["sfacg"],
+    backends=["session", "browser"],
+)
 class SfacgParser(BaseParser):
     """ """
 

novel_downloader/core/parsers/{yamibo/main_parser.py → yamibo.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.parsers.yamibo.main_parser
-------------------------------------------------
+novel_downloader.core.parsers.yamibo
+------------------------------------
 
 """
 
@@ -10,9 +10,14 @@ from typing import Any
 from lxml import html
 
 from novel_downloader.core.parsers.base import BaseParser
+from novel_downloader.core.parsers.registry import register_parser
 from novel_downloader.models import ChapterDict
 
 
+@register_parser(
+    site_keys=["yamibo"],
+    backends=["session", "browser"],
+)
 class YamiboParser(BaseParser):
     """ """
 

novel_downloader/core/searchers/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers
+-------------------------------
+
+"""
+
+__all__ = [
+    "search",
+    "BiqugeSearcher",
+    "EsjzoneSearcher",
+    "QianbiSearcher",
+    "QidianSearcher",
+]
+
+from .biquge import BiqugeSearcher
+from .esjzone import EsjzoneSearcher
+from .qianbi import QianbiSearcher
+from .qidian import QidianSearcher
+from .registry import search

novel_downloader/core/searchers/base.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.base
+------------------------------------
+
+"""
+
+import abc
+from typing import Any
+from urllib.parse import quote_plus
+
+import requests
+
+from novel_downloader.core.interfaces import SearcherProtocol
+from novel_downloader.models import SearchResult
+from novel_downloader.utils.constants import DEFAULT_USER_HEADERS
+
+
+class BaseSearcher(abc.ABC, SearcherProtocol):
+    site_name: str
+    _session = requests.Session()
+    _DEFAULT_TIMEOUT: tuple[int, int] = (5, 10)
+
+    @classmethod
+    def search(cls, keyword: str, limit: int | None = None) -> list[SearchResult]:
+        html = cls._fetch_html(keyword)
+        return cls._parse_html(html, limit)
+
+    @classmethod
+    @abc.abstractmethod
+    def _fetch_html(cls, keyword: str) -> str:
+        """Get raw HTML from search API or page"""
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        """Parse HTML into standard search result list"""
+        pass
+
+    @classmethod
+    def _http_get(
+        cls,
+        url: str,
+        *,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: tuple[int, int] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        """
+        Helper for GET requests with default headers, timeout, and error-raising.
+        """
+        hdrs = {**DEFAULT_USER_HEADERS, **(headers or {})}
+        resp = cls._session.get(
+            url,
+            params=params,
+            headers=hdrs,
+            timeout=timeout or cls._DEFAULT_TIMEOUT,
+            **kwargs,
+        )
+        resp.raise_for_status()
+        return resp
+
+    @classmethod
+    def _http_post(
+        cls,
+        url: str,
+        *,
+        data: dict[str, str] | str | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: tuple[int, int] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        """
+        Helper for POST requests with default headers, timeout, and error-raising.
+        """
+        hdrs = {**DEFAULT_USER_HEADERS, **(headers or {})}
+        resp = cls._session.post(
+            url,
+            data=data,
+            headers=hdrs,
+            timeout=timeout or cls._DEFAULT_TIMEOUT,
+            **kwargs,
+        )
+        resp.raise_for_status()
+        return resp
+
+    @staticmethod
+    def _quote(q: str) -> str:
+        """URL-encode a query string safely."""
+        return quote_plus(q)

novel_downloader/core/searchers/biquge.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.biquge
+--------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["biquge", "bqg"],
+)
+class BiqugeSearcher(BaseSearcher):
+    site_name = "biquge"
+    priority = 5
+    SEARCH_URL = "http://www.b520.cc/modules/article/search.php"
+
+    @classmethod
+    def _fetch_html(cls, keyword: str) -> str:
+        """
+        Fetch raw HTML from Biquge's search page.
+
+        :param keyword: The search term to query on Biquge.
+        :return: HTML text of the search results page, or an empty string on fail.
+        """
+        params = {"searchkey": keyword}
+        try:
+            response = cls._http_get(cls.SEARCH_URL, params=params)
+            return response.text
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+                exc_info=True,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        """
+        Parse raw HTML from Biquge search results into list of SearchResult.
+
+        :param html_str: Raw HTML string from Biquge search results page.
+        :param limit: Maximum number of results to return, or None for all.
+        :return: List of SearchResult dicts.
+        """
+        doc = html.fromstring(html_str)
+        rows = doc.xpath('//table[@class="grid"]//tr[position()>1]')
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            if limit is not None and idx >= limit:
+                break
+            # Title and book_id
+            title_elem = row.xpath(".//td[1]/a")[0]
+            title = title_elem.text_content().strip()
+            href = title_elem.get("href", "").strip("/")
+            book_id = href.split("/")[0] if href else ""
+            # Author
+            author = row.xpath(".//td[3]")[0].text_content().strip()
+            # Compute priority
+            prio = cls.priority + idx
+
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    title=title,
+                    author=author,
+                    priority=prio,
+                )
+            )
+        return results

novel_downloader/core/searchers/esjzone.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.esjzone
+---------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["esjzone"],
+)
+class EsjzoneSearcher(BaseSearcher):
+    site_name = "esjzone"
+    priority = 3
+    SEARCH_URL = "https://www.esjzone.cc/tags/{query}/"
+
+    @classmethod
+    def _fetch_html(cls, keyword: str) -> str:
+        """
+        Fetch raw HTML from Esjzone's search page.
+
+        :param keyword: The search term to query on Esjzone.
+        :return: HTML text of the search results page, or an empty string on fail.
+        """
+        url = cls.SEARCH_URL.format(query=cls._quote(keyword))
+        try:
+            response = cls._http_get(url)
+            return response.text
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                url,
+                exc_info=True,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        """
+        Parse raw HTML from Esjzone search results into list of SearchResult.
+
+        :param html_str: Raw HTML string from Esjzone search results page.
+        :param limit: Maximum number of results to return, or None for all.
+        :return: List of SearchResult dicts.
+        """
+        doc = html.fromstring(html_str)
+        cards = doc.xpath('//div[contains(@class,"card-body")]')
+        results: list[SearchResult] = []
+
+        for idx, card in enumerate(cards):
+            if limit is not None and idx >= limit:
+                break
+            # Title and book_id
+            link = card.xpath('.//h5[@class="card-title"]/a')[0]
+            title = link.text_content().strip()
+            href = link.get("href", "")
+            # href format: /detail/<book_id>.html
+            book_id = href.strip("/").replace("detail/", "").replace(".html", "")
+            # Author
+            author_link = card.xpath('.//div[@class="card-author"]/a')[0]
+            author = author_link.text_content().strip()
+            # Compute priority incrementally
+            prio = cls.priority + idx
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    title=title,
+                    author=author,
+                    priority=prio,
+                )
+            )
+        return results