novel-downloader 2.0.0__tar.gz → 2.0.1__tar.gz

{novel_downloader-2.0.0/src/novel_downloader.egg-info → novel_downloader-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: novel-downloader
-Version: 2.0.0
+Version: 2.0.1
 Summary: A command-line tool for downloading Chinese web novels from Qidian and similar platforms.
 Author-email: Saudade Z <saudadez217@gmail.com>
 License: MIT License
@@ -47,6 +47,7 @@ Requires-Dist: aiohttp
 Requires-Dist: lxml
 Requires-Dist: platformdirs
 Provides-Extra: font-recovery
+Requires-Dist: brotli; extra == "font-recovery"
 Requires-Dist: numpy; extra == "font-recovery"
 Requires-Dist: fonttools; extra == "font-recovery"
 Requires-Dist: pillow; extra == "font-recovery"

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/pyproject.toml

@@ -31,6 +31,7 @@ dependencies = [
 
 [project.optional-dependencies]
 font-recovery = [
+    "brotli",
     "numpy",
     "fonttools",
     "pillow",
@@ -110,7 +111,7 @@ testpaths = ["tests"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "2.0.0"
+version = "2.0.1"
 version_files = [
     "src/novel_downloader/__init__.py"
 ]

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/__init__.py

@@ -6,7 +6,7 @@ novel_downloader
 Core package for the Novel Downloader project.
 """
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 
 __author__ = "Saudade Z"
 __email__ = "saudadez217@gmail.com"

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/cli/download.py

@@ -155,7 +155,7 @@ async def _download(
     exporter_cfg = adapter.get_exporter_config()
     login_cfg = adapter.get_login_config()
     log_level = adapter.get_log_level()
-    setup_logging(log_level=log_level)
+    setup_logging(console_level=log_level)
 
     parser = get_parser(site, parser_cfg)
     exporter = None
@@ -214,8 +214,8 @@ async def _prompt_login_fields(
             ui.info(t("login_use_config"))
             continue
 
-        value: str | dict[str, str]
-        while True:
+        value: str | dict[str, str] = ""
+        for _ in range(5):
             if field.type == "password":
                 value = ui.prompt_password(t("login_enter_password"))
             elif field.type == "cookie":

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/cli/export.py

@@ -56,7 +56,7 @@ def handle_export(args: Namespace) -> None:
     exporter_cfg = adapter.get_exporter_config()
     log_level = adapter.get_log_level()
     exporter = get_exporter(site, exporter_cfg)
-    setup_logging(log_level=log_level)
+    setup_logging(console_level=log_level)
 
     for book_id in book_ids:
         ui.info(t("export_processing", book_id=book_id, format=export_format))

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/cli/ui.py

@@ -7,12 +7,12 @@ A small set of Rich-based helpers to keep CLI presentation and prompts
 consistent across subcommands.
 
 Public API:
-- info, success, warn, error
-- confirm
-- prompt, prompt_password
-- render_table
-- select_index
-- print_progress
+  * info, success, warn, error
+  * confirm
+  * prompt, prompt_password
+  * render_table
+  * select_index
+  * print_progress
 """
 
 from __future__ import annotations
@@ -71,7 +71,7 @@ def prompt(message: str, *, default: str | None = None) -> str:
     :return: The user's input.
     """
     try:
-        result: str = Prompt.ask(message, default=default or "")
+        result: str = Prompt.ask(message, default=default or "", show_default=False)
         return result
     except (KeyboardInterrupt, EOFError):
         warn("Cancelled.")

novel_downloader-2.0.1/src/novel_downloader/config/adapter.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.config.adapter
+-------------------------------
+
+Defines ConfigAdapter, which maps a raw configuration dictionary and
+site into structured dataclass-based config models.
+"""
+
+import contextlib
+import json
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from novel_downloader.models import (
+    BookConfig,
+    DownloaderConfig,
+    ExporterConfig,
+    FetcherConfig,
+    ParserConfig,
+    TextCleanerConfig,
+)
+
+T = TypeVar("T")
+
+
+class ConfigAdapter:
+    """
+    Adapter to map a raw configuration dictionary and site name
+    into structured dataclass configuration models.
+
+    Resolution order for each field:
+      1. ``config["sites"][<site>]`` (if present)
+      2. ``config["general"]`` (if present)
+      3. Hard-coded default passed by the caller
+    """
+
+    def __init__(self, config: Mapping[str, Any], site: str):
+        """
+        Initialize the adapter with a configuration mapping and a site key.
+
+        :param config: Fully loaded configuration mapping.
+        :param site: Current site key (e.g., ``"qidian"``).
+        """
+        self._config: dict[str, Any] = dict(config)
+        self._site: str = site
+
+    def get_fetcher_config(self) -> FetcherConfig:
+        """
+        Build a :class:`novel_downloader.models.FetcherConfig` by resolving fields
+        from site-specific and general settings.
+
+        :return: Fully populated configuration for the network fetcher.
+        """
+        s, g = self._site_cfg, self._gen_cfg
+        return FetcherConfig(
+            request_interval=self._pick("request_interval", 2.0, s, g),
+            retry_times=self._pick("retry_times", 3, s, g),
+            backoff_factor=self._pick("backoff_factor", 2.0, s, g),
+            timeout=self._pick("timeout", 30.0, s, g),
+            max_connections=self._pick("max_connections", 10, s, g),
+            max_rps=self._pick("max_rps", 1000.0, s, g),
+            user_agent=self._pick("user_agent", None, s, g),
+            headers=self._pick("headers", None, s, g),
+            verify_ssl=self._pick("verify_ssl", True, s, g),
+            locale_style=self._pick("locale_style", "simplified", s, g),
+        )
+
+    def get_downloader_config(self) -> DownloaderConfig:
+        """
+        Build a :class:`novel_downloader.models.DownloaderConfig` using both
+        general and site-specific settings.
+
+        :return: Fully populated configuration for the chapter/page downloader.
+        """
+        s, g = self._site_cfg, self._gen_cfg
+        debug = g.get("debug") or {}
+        return DownloaderConfig(
+            request_interval=self._pick("request_interval", 2.0, s, g),
+            retry_times=self._pick("retry_times", 3, s, g),
+            backoff_factor=self._pick("backoff_factor", 2.0, s, g),
+            workers=self._pick("workers", 2, s, g),
+            skip_existing=self._pick("skip_existing", True, s, g),
+            login_required=bool(s.get("login_required", False)),
+            save_html=bool(debug.get("save_html", False)),
+            raw_data_dir=g.get("raw_data_dir", "./raw_data"),
+            cache_dir=g.get("cache_dir", "./novel_cache"),
+            storage_batch_size=g.get("storage_batch_size", 1),
+        )
+
+    def get_parser_config(self) -> ParserConfig:
+        """
+        Build a :class:`novel_downloader.models.ParserConfig` from general,
+        OCR-related, and site-specific settings.
+
+        :return: Fully populated configuration for the parser stage.
+        """
+        g = self._gen_cfg
+        s = self._site_cfg
+        font_ocr = g.get("font_ocr") or {}
+        return ParserConfig(
+            cache_dir=g.get("cache_dir", "./novel_cache"),
+            use_truncation=bool(s.get("use_truncation", True)),
+            decode_font=bool(font_ocr.get("decode_font", False)),
+            save_font_debug=bool(font_ocr.get("save_font_debug", False)),
+            batch_size=int(font_ocr.get("batch_size", 32)),
+        )
+
+    def get_exporter_config(self) -> ExporterConfig:
+        """
+        Build an :class:`novel_downloader.models.ExporterConfig` from the
+        ``output`` and ``cleaner`` sections plus general settings.
+
+        :return: Fully populated configuration for text/ebook export.
+        """
+        g = self._gen_cfg
+        out = self._config.get("output") or {}
+        cln = self._config.get("cleaner") or {}
+        fmt = out.get("formats") or {}
+        naming = out.get("naming") or {}
+        epub_opts = out.get("epub") or {}
+
+        cleaner_cfg = self._dict_to_cleaner_cfg(cln)
+        return ExporterConfig(
+            cache_dir=g.get("cache_dir", "./novel_cache"),
+            raw_data_dir=g.get("raw_data_dir", "./raw_data"),
+            output_dir=g.get("output_dir", "./downloads"),
+            clean_text=cln.get("clean_text", False),
+            make_txt=fmt.get("make_txt", True),
+            make_epub=fmt.get("make_epub", True),
+            make_md=fmt.get("make_md", False),
+            make_pdf=fmt.get("make_pdf", False),
+            append_timestamp=naming.get("append_timestamp", True),
+            filename_template=naming.get("filename_template", "{title}_{author}"),
+            include_cover=epub_opts.get("include_cover", True),
+            include_picture=epub_opts.get("include_picture", True),
+            split_mode=self._site_cfg.get("split_mode", "book"),
+            cleaner_cfg=cleaner_cfg,
+        )
+
+    def get_login_config(self) -> dict[str, str]:
+        """
+        Extract login-related fields from the current site configuration.
+        Only non-empty string values are returned; values are stripped.
+
+        :return: A subset of ``{"username","password","cookies"}`` that are non-empty
+        """
+        out: dict[str, str] = {}
+        for key in ("username", "password", "cookies"):
+            val = self._site_cfg.get(key, "")
+            if isinstance(val, str):
+                s = val.strip()
+                if s:
+                    out[key] = s
+        return out
+
+    def get_book_ids(self) -> list[BookConfig]:
+        """
+        Extract and normalize the list of target books for the current site.
+
+        Accepted shapes for ``site.book_ids``:
+          * a single ``str`` or ``int`` (book id)
+          * a dict  with fields: book_id and optional start_id, end_id, ignore_ids
+          * a ``list`` containing any mix of the above
+
+        :return: Normalized list of :class:`BookConfig`-compatible dictionaries.
+        :raises ValueError: If ``book_ids`` is neither a scalar ``str|int``, ``dict``,
+                            nor ``list``.
+        """
+        raw = self._site_cfg.get("book_ids", [])
+
+        if isinstance(raw, (str | int)):
+            return [{"book_id": str(raw)}]
+
+        if isinstance(raw, dict):
+            return [self._dict_to_book_cfg(raw)]
+
+        if not isinstance(raw, list):
+            raise ValueError(
+                f"book_ids must be a list or string, got {type(raw).__name__}"
+            )
+
+        result: list[BookConfig] = []
+        for item in raw:
+            try:
+                if isinstance(item, (str | int)):
+                    result.append({"book_id": str(item)})
+                elif isinstance(item, dict):
+                    result.append(self._dict_to_book_cfg(item))
+            except ValueError:
+                continue
+        return result
+
+    def get_log_level(self) -> str:
+        """
+        Retrieve the logging level from ``general.debug``.
+
+        :return: One of ``"DEBUG"``, ``"INFO"``, ``"WARNING"``, ``"ERROR"``
+        """
+        debug_cfg = self._gen_cfg.get("debug", {})
+        return debug_cfg.get("log_level") or "INFO"
+
+    @property
+    def site(self) -> str:
+        return self._site
+
+    @site.setter
+    def site(self, value: str) -> None:
+        self._site = value
+
+    @property
+    def _gen_cfg(self) -> dict[str, Any]:
+        """
+        A read-only view of the global ``general`` settings.
+
+        :return: ``config["general"]`` if present, else ``{}``.
+        """
+        return self._config.get("general") or {}
+
+    @property
+    def _site_cfg(self) -> dict[str, Any]:
+        """
+        Retrieve the configuration block for the current site.
+
+        Lookup order:
+          1. If a site-specific entry exists under ``config["sites"]``, return it.
+          2. Otherwise, if ``config["sites"]["common"]`` exists, return it.
+          3. Else return an empty dict.
+
+        :return: Site-specific mapping, common mapping, or ``{}``.
+        """
+        sites_cfg = self._config.get("sites") or {}
+        if self._site in sites_cfg and isinstance(sites_cfg[self._site], dict):
+            return sites_cfg[self._site] or {}
+        return sites_cfg.get("common") or {}
+
+    @staticmethod
+    def _has_key(d: Mapping[str, Any] | None, key: str) -> bool:
+        """
+        Check whether a mapping contains a key.
+
+        :param d: Mapping to inspect.
+        :param key: Key to look up.
+        :return: ``True`` if ``d`` is a Mapping and contains key; otherwise ``False``.
+        """
+        return isinstance(d, Mapping) and (key in d)
+
+    def _pick(self, key: str, default: T, *sources: Mapping[str, Any]) -> T:
+        """
+        Resolve ``key`` from the provided ``sources`` in order of precedence.
+
+        :param key: Configuration key to resolve.
+        :param default: Fallback value if ``key`` is absent in all sources.
+        :param sources: One or more mappings to check, in order of precedence.
+        :return: The first present value for ``key``, otherwise ``default``.
+        """
+        for src in sources:
+            if self._has_key(src, key):
+                return src[key]  # type: ignore[no-any-return]
+        return default
+
+    @staticmethod
+    def _dict_to_book_cfg(data: dict[str, Any]) -> BookConfig:
+        """
+        Convert a raw dict into a :class:`novel_downloader.models.BookConfig`
+        with normalized types (all IDs coerced to strings).
+
+        :param data: A dict that must contain at least "book_id".
+        :return: Normalized :class:`BookConfig` mapping.
+        :raises ValueError: If ``"book_id"`` is missing.
+        """
+        if "book_id" not in data:
+            raise ValueError("Missing required field 'book_id'")
+
+        out: BookConfig = {"book_id": str(data["book_id"])}
+
+        if "start_id" in data:
+            out["start_id"] = str(data["start_id"])
+        if "end_id" in data:
+            out["end_id"] = str(data["end_id"])
+        if "ignore_ids" in data:
+            with contextlib.suppress(Exception):
+                out["ignore_ids"] = [str(x) for x in data["ignore_ids"]]
+        return out
+
+    @classmethod
+    def _dict_to_cleaner_cfg(cls, cfg: dict[str, Any]) -> TextCleanerConfig:
+        """
+        Convert a nested ``cleaner`` block into a
+        :class:`novel_downloader.models.TextCleanerConfig`.
+
+        :param cfg: configuration dictionary
+        :return: Aggregated title/content rules with external file contents merged
+        """
+        t_remove, t_replace = cls._merge_rules(cfg.get("title", {}) or {})
+        c_remove, c_replace = cls._merge_rules(cfg.get("content", {}) or {})
+        return TextCleanerConfig(
+            remove_invisible=cfg.get("remove_invisible", True),
+            title_remove_patterns=t_remove,
+            title_replacements=t_replace,
+            content_remove_patterns=c_remove,
+            content_replacements=c_replace,
+        )
+
+    @classmethod
+    def _merge_rules(cls, section: dict[str, Any]) -> tuple[list[str], dict[str, str]]:
+        """
+        Merge inline patterns/replacements with any enabled external files.
+
+        :param section: Mapping describing either the ``title`` or ``content`` rules.
+        :return: Tuple ``(remove_patterns, replace)`` after merging.
+        """
+        remove = list(section.get("remove_patterns") or [])
+        replace = dict(section.get("replace") or {})
+        ext = section.get("external") or {}
+        if ext.get("enabled", False):
+            rm_path = ext.get("remove_patterns") or ""
+            rp_path = ext.get("replace") or ""
+            remove += cls._load_str_list(rm_path)
+            replace.update(cls._load_str_dict(rp_path))
+        return remove, replace
+
+    @staticmethod
+    def _load_str_list(path: str) -> list[str]:
+        """
+        Load a JSON file containing a list of strings.
+
+        :param path: File path to a JSON array (e.g., ``["a", "b"]``).
+        :return: Parsed list on success; empty list if ``path`` is empty, file is
+                 missing, or content is invalid.
+        """
+        if not path:
+            return []
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+                return list(data) if isinstance(data, list) else []
+        except Exception:
+            return []
+
+    @staticmethod
+    def _load_str_dict(path: str) -> dict[str, str]:
+        """
+        Load a JSON file containing a dict of string-to-string mappings.
+
+        :param path: File path to a JSON object (e.g., ``{"old":"new"}``).
+        :return: Parsed dict on success; empty dict if ``path`` is empty, file is
+                 missing, or content is invalid.
+        """
+        if not path:
+            return {}
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+                return dict(data) if isinstance(data, dict) else {}
+        except Exception:
+            return {}

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/__init__.py

@@ -7,12 +7,11 @@ This package serves as the core layer of the novel_downloader system.
 
 It provides factory methods for constructing key components required for
 downloading and processing online novel content, including:
-
-- Downloader: Handles the full download lifecycle of a book or a batch of books.
-- Parser: Extracts structured data from HTML or SSR content.
-- Fetcher: Sends HTTP requests and manages sessions, including login if required.
-- Exporter: Responsible for exporting downloaded data into various output formats.
-- search: Provides unified search functionality across supported novel sites.
+  * Downloader: Handles the full download lifecycle of a book or a batch of books.
+  * Parser: Extracts structured data from HTML or SSR content.
+  * Fetcher: Sends HTTP requests and manages sessions, including login if required.
+  * Exporter: Responsible for exporting downloaded data into various output formats.
+  * search: Provides unified search functionality across supported novel sites.
 """
 
 __all__ = [

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/exporters/common/txt.py

@@ -133,14 +133,14 @@ def common_export_as_txt(
     out_path = out_dir / out_name
 
     # --- Save final text ---
-    result = write_file(
-        content=final_text,
-        filepath=out_path,
-        write_mode="w",
-        on_exist="overwrite",
-    )
-    if result:
+    try:
+        result = write_file(
+            content=final_text,
+            filepath=out_path,
+            on_exist="overwrite",
+        )
         exporter.logger.info("%s Novel saved to: %s", TAG, out_path)
-    else:
-        exporter.logger.error("%s Failed to write novel to %s", TAG, out_path)
+    except Exception as e:
+        exporter.logger.error("%s Failed to write novel to %s: %s", TAG, out_path, e)
+        return None
     return result

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/exporters/linovelib/txt.py

@@ -126,14 +126,14 @@ def linovelib_export_as_txt(
     out_path = out_dir / out_name
 
     # --- Save final text ---
-    result = write_file(
-        content=final_text,
-        filepath=out_path,
-        write_mode="w",
-        on_exist="overwrite",
-    )
-    if result:
+    try:
+        result = write_file(
+            content=final_text,
+            filepath=out_path,
+            on_exist="overwrite",
+        )
         exporter.logger.info("%s Novel saved to: %s", TAG, out_path)
-    else:
-        exporter.logger.error("%s Failed to write novel to %s", TAG, out_path)
+    except Exception as e:
+        exporter.logger.error("%s Failed to write novel to %s: %s", TAG, out_path, e)
+        return None
     return result

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/fetchers/qidian.py

@@ -18,10 +18,8 @@ import aiohttp
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
 from novel_downloader.models import FetcherConfig, LoginField
-from novel_downloader.utils import (
-    async_jitter_sleep,
-    rc4_crypt,
-)
+from novel_downloader.utils import async_jitter_sleep
+from novel_downloader.utils.crypto_utils.rc4 import rc4_init, rc4_stream
 
 
 @register_fetcher(
@@ -54,6 +52,8 @@ class QidianSession(BaseSession):
         **kwargs: Any,
     ) -> None:
         super().__init__("qidian", config, cookies, **kwargs)
+        self._s_init = rc4_init(self._d2("dGcwOUl0Myo5aA=="))
+        self._cookie_key = self._d("d190c2Zw")
         self._fp_key = self._d("ZmluZ2VycHJpbnQ=")
         self._ab_key = self._d("YWJub3JtYWw=")
         self._ck_key = self._d("Y2hlY2tzdW0=")
@@ -165,12 +165,10 @@ class QidianSession(BaseSession):
         if self._rate_limiter:
             await self._rate_limiter.wait()
 
-        cookie_key = self._d("d190c2Zw")
-
         for attempt in range(self.retry_times + 1):
             try:
                 refreshed_token = self._build_payload_token(url)
-                self.update_cookies({cookie_key: refreshed_token})
+                self.update_cookies({self._cookie_key: refreshed_token})
 
                 async with self.session.get(url, **kwargs) as resp:
                     resp.raise_for_status()
@@ -227,40 +225,30 @@ class QidianSession(BaseSession):
         """
         return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
 
-    def _update_fp_val(
-        self,
-        *,
-        key: str = "",
-    ) -> None:
-        """"""
-        enc_token = self._get_cookie_value(self._d("d190c2Zw"))
+    def _update_fp_val(self) -> None:
+        """
+        Decrypt the payload from cookie and update `_fp_val` and `_ab_val`.
+        """
+        enc_token = self._get_cookie_value(self._cookie_key)
         if not enc_token:
             return
-        if not key:
-            key = self._get_key()
-        decrypted_json: str = rc4_crypt(key, enc_token, mode="decrypt")
+
+        cipher_bytes = base64.b64decode(enc_token)
+        plain_bytes = rc4_stream(self._s_init, cipher_bytes)
+        decrypted_json = plain_bytes.decode("utf-8", errors="replace")
         payload: dict[str, Any] = json.loads(decrypted_json)
         self._fp_val = payload.get(self._fp_key, "")
         self._ab_val = payload.get(self._ab_key, "0" * 32)
 
-    def _build_payload_token(
-        self,
-        new_uri: str,
-        *,
-        key: str = "",
-    ) -> str:
+    def _build_payload_token(self, new_uri: str) -> str:
         """
         Patch a timestamp-bearing token with fresh timing and checksum info.
 
         :param new_uri: URI used in checksum generation.
-        :param key: RC4 key extracted from front-end JavaScript (optional).
-
         :return: Updated token with new timing and checksum values.
         """
         if not self._fp_val or not self._ab_val:
             self._update_fp_val()
-        if not key:
-            key = self._get_key()
 
         # rebuild timing fields
         loadts = int(time.time() * 1000)  # ms since epoch
@@ -278,9 +266,9 @@ class QidianSession(BaseSession):
             self._ab_key: self._ab_val,
             self._ck_key: ck_val,
         }
-        return rc4_crypt(
-            key, json.dumps(new_payload, separators=(",", ":")), mode="encrypt"
-        )
+        plain_bytes = json.dumps(new_payload, separators=(",", ":")).encode("utf-8")
+        cipher_bytes = rc4_stream(self._s_init, plain_bytes)
+        return base64.b64encode(cipher_bytes).decode("utf-8")
 
     async def _check_login_status(self) -> bool:
         """
@@ -335,8 +323,5 @@ class QidianSession(BaseSession):
         return base64.b64decode(b).decode()
 
     @staticmethod
-    def _get_key() -> str:
-        encoded = "Lj1qYxMuaXBjMg=="
-        decoded = base64.b64decode(encoded)
-        key = "".join([chr(b ^ 0x5A) for b in decoded])
-        return key
+    def _d2(b: str) -> bytes:
+        return base64.b64decode(b)

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/interfaces/fetcher.py

@@ -16,8 +16,8 @@ from novel_downloader.models import LoginField
 class FetcherProtocol(Protocol):
     """
     An async requester must be able to fetch raw HTML/data for:
-      - a book's info page,
-      - a specific chapter page,
+      * a book's info page,
+      * a specific chapter page,
     and manage login/shutdown asynchronously.
     """
 

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/interfaces/parser.py

@@ -15,8 +15,8 @@ from novel_downloader.models import BookInfoDict, ChapterDict
 class ParserProtocol(Protocol):
     """
     A parser must be able to:
-      - extract book metadata from an HTML string,
-      - extract a single chapter's text from an HTML string
+      * extract book metadata from an HTML string,
+      * extract a single chapter's text from an HTML string
     """
 
     def parse_book_info(

{novel_downloader-2.0.0 → novel_downloader-2.0.1}/src/novel_downloader/core/parsers/base.py

@@ -43,6 +43,7 @@ class BaseParser(ParserProtocol, abc.ABC):
         self._config = config
         self._book_id: str | None = None
 
+        self._save_font_debug = config.save_font_debug
         self._decode_font: bool = config.decode_font
         self._use_truncation = config.use_truncation
         self._base_cache_dir = Path(config.cache_dir)