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

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

@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.utils.fontmap_recover
-----------------------------------------------------------
-
-Tools for generating and applying font character mappings
-to recover obfuscated Qidian text.
-"""
-
-__all__ = [
-    "generate_font_map",
-    "apply_font_mapping",
-]
-
-import json
-import logging
-from pathlib import Path
-
-import numpy as np
-from fontTools.ttLib import TTFont
-from PIL import ImageFont
-
-logger = logging.getLogger(__name__)
-CHAR_FONT_SIZE = 52
-
-
-def generate_font_map(
-    fixed_font_path: Path,
-    random_font_path: Path,
-    char_set: set[str],
-    refl_set: set[str],
-    cache_dir: Path,
-    batch_size: int = 32,
-) -> dict[str, str]:
-    """
-    Build a mapping from scrambled font chars to real chars.
-
-    Uses OCR to compare rendered glyphs from a known (fixed) font and an
-    obfuscated (random) font. Results are cached in JSON so repeated runs
-    are faster.
-
-    :param fixed_font_path: fixed font file.
-    :param random_font_path: random font file.
-    :param char_set: Characters to match directly.
-    :param refl_set: Characters to match in flipped form.
-    :param cache_dir: Directory to save/load cached results.
-    :param batch_size: How many chars to OCR per batch.
-
-    :return: { obf_char: real_char, ... }
-    """
-    try:
-        from novel_downloader.utils.fontocr import get_font_ocr
-
-        font_ocr = get_font_ocr(batch_size=batch_size)
-    except ImportError:
-        logger.warning("[QidianParser] FontOCR not available, font decoding will skip")
-        return {}
-
-    mapping_result: dict[str, str] = {}
-    fixed_map_file = cache_dir / "fixed_font_map" / f"{Path(fixed_font_path).stem}.json"
-    fixed_map_file.parent.mkdir(parents=True, exist_ok=True)
-
-    # load existing cache
-    try:
-        with open(fixed_map_file, encoding="utf-8") as f:
-            fixed_map = json.load(f)
-        cached_chars = set(fixed_map.keys())
-        mapping_result.update({ch: fixed_map[ch] for ch in char_set if ch in fixed_map})
-        mapping_result.update({ch: fixed_map[ch] for ch in refl_set if ch in fixed_map})
-        char_set = set(char_set) - cached_chars
-        refl_set = set(refl_set) - cached_chars
-    except Exception:
-        fixed_map = {}
-        cached_chars = set()
-
-    # prepare font renderers and cmap sets
-    try:
-        fixed_ttf = TTFont(fixed_font_path)
-        fixed_chars = {chr(c) for c in fixed_ttf.getBestCmap()}
-        fixed_font = ImageFont.truetype(str(fixed_font_path), CHAR_FONT_SIZE)
-
-        random_ttf = TTFont(random_font_path)
-        random_chars = {chr(c) for c in random_ttf.getBestCmap()}
-        random_font = ImageFont.truetype(str(random_font_path), CHAR_FONT_SIZE)
-    except Exception as e:
-        logger.error("[FontOCR] Failed to load TTF fonts: %s", e)
-        return mapping_result
-
-    def _render_batch(chars: list[tuple[str, bool]]) -> list[tuple[str, np.ndarray]]:
-        out = []
-        for ch, reflect in chars:
-            if ch in fixed_chars:
-                font = fixed_font
-            elif ch in random_chars:
-                font = random_font
-            else:
-                continue
-            img = font_ocr.render_char_image_array(ch, font, reflect)
-            if img is not None:
-                out.append((ch, img))
-        return out
-
-    # process normal and reflected sets together
-    for chars, reflect in [(list(char_set), False), (list(refl_set), True)]:
-        for batch_chars in font_ocr._chunked(chars, font_ocr._batch_size):
-            # render all images in this batch
-            to_render = [(ch, reflect) for ch in batch_chars]
-            rendered = _render_batch(to_render)
-            if not rendered:
-                continue
-
-            # query OCR+vec simultaneously
-            imgs_to_query = [img for (ch, img) in rendered]
-            fused = font_ocr.predict(imgs_to_query, top_k=1)
-
-            # pick best per char, apply threshold + cache
-            for (ch, _), preds in zip(rendered, fused, strict=False):
-                if not preds:
-                    continue
-                real_char, _ = preds[0]
-                mapping_result[ch] = real_char
-                fixed_map[ch] = real_char
-
-    # persist updated fixed_map
-    try:
-        with open(fixed_map_file, "w", encoding="utf-8") as f:
-            json.dump(fixed_map, f, ensure_ascii=False, indent=2)
-    except Exception as e:
-        logger.error("[FontOCR] Failed to save fixed map: %s", e)
-
-    return mapping_result
-
-
-def apply_font_mapping(text: str, font_map: dict[str, str]) -> str:
-    """
-    Replace each character in `text` using `font_map`,
-    leaving unmapped characters unchanged.
-
-    :param text: The input string, possibly containing obfuscated font chars.
-    :param font_map: A dict mapping obfuscated chars to real chars.
-    :return: The de-obfuscated text.
-    """
-    return "".join(font_map.get(ch, ch) for ch in text)

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

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.utils.helpers
---------------------------------------------------
-
-Shared utility functions for parsing Qidian pages.
-"""
-
-import json
-import logging
-from typing import Any
-
-from lxml import html
-
-logger = logging.getLogger(__name__)
-
-
-def find_ssr_page_context(html_str: str) -> dict[str, Any]:
-    """
-    Extract SSR JSON from <script id="vite-plugin-ssr_pageContext">.
-    """
-    try:
-        tree = html.fromstring(html_str)
-        script = tree.xpath('//script[@id="vite-plugin-ssr_pageContext"]/text()')
-        if script:
-            data: dict[str, Any] = json.loads(script[0].strip())
-            return data
-    except Exception as e:
-        logger.warning("[Parser] SSR JSON parse error: %s", e)
-    return {}
-
-
-def extract_chapter_info(ssr_data: dict[str, Any]) -> dict[str, Any]:
-    """
-    Extract the 'chapterInfo' dictionary from the SSR page context.
-
-    This handles nested key access and returns an empty dict if missing.
-
-    :param ssr_data: The full SSR data object from _find_ssr_page_context().
-    :return: A dict with chapter metadata such as chapterName, authorSay, etc.
-    """
-    try:
-        page_context = ssr_data.get("pageContext", {})
-        page_props = page_context.get("pageProps", {})
-        page_data = page_props.get("pageData", {})
-        chapter_info = page_data.get("chapterInfo", {})
-
-        assert isinstance(chapter_info, dict)
-        return chapter_info
-    except Exception:
-        return {}
-
-
-def is_restricted_page(html_str: str) -> bool:
-    """
-    Return True if page content indicates access restriction
-    (e.g. not subscribed/purchased).
-
-    :param html_str: Raw HTML string.
-    """
-    markers = ["这是VIP章节", "需要订阅", "订阅后才能阅读"]
-    return any(m in html_str for m in markers)
-
-
-def vip_status(ssr_data: dict[str, Any]) -> bool:
-    """
-    :return: True if VIP, False otherwise.
-    """
-    chapter_info = extract_chapter_info(ssr_data)
-    vip_flag = chapter_info.get("vipStatus", 0)
-    fens_flag = chapter_info.get("fEnS", 0)
-    return bool(vip_flag == 1 and fens_flag != 0)
-
-
-def can_view_chapter(ssr_data: dict[str, Any]) -> bool:
-    """
-    A chapter is not viewable if it is marked as VIP
-    and has not been purchased.
-
-    :return: True if viewable, False otherwise.
-    """
-    chapter_info = extract_chapter_info(ssr_data)
-    is_buy = chapter_info.get("isBuy", 0)
-    vip_status = chapter_info.get("vipStatus", 0)
-    return not (vip_status == 1 and is_buy == 0)
-
-
-def is_duplicated(ssr_data: dict[str, Any]) -> bool:
-    """
-    Check if chapter is marked as duplicated (eFW = 1).
-    """
-    chapter_info = extract_chapter_info(ssr_data)
-    efw_flag = chapter_info.get("eFW", 0)
-    return bool(efw_flag == 1)
-
-
-def is_encrypted(content: str | dict[str, Any]) -> bool:
-    """
-    Return True if content is encrypted.
-
-    Chapter Encryption Status (cES):
-    - 0: 内容是'明文'
-    - 2: 字体加密
-
-    :param content: HTML content, either as a raw string or a BeautifulSoup object.
-    :return: True if encrypted marker is found, else False.
-    """
-    ssr_data = find_ssr_page_context(content) if isinstance(content, str) else content
-    chapter_info = extract_chapter_info(ssr_data)
-    return int(chapter_info.get("cES", 0)) == 2