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

novel_downloader/core/parsers/jpxs123.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.jpxs123
+-------------------------------------
+
+"""
+
+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 (
+    BookInfoDict,
+    ChapterDict,
+    ChapterInfoDict,
+    VolumeInfoDict,
+)
+
+
+@register_parser(
+    site_keys=["jpxs123"],
+)
+class Jpxs123Parser(BaseParser):
+    """
+    Parser for 精品小说网 book pages.
+    """
+
+    BASE_URL = "https://www.jpxs123.com"
+
+    def parse_book_info(
+        self,
+        html_list: list[str],
+        **kwargs: Any,
+    ) -> BookInfoDict | None:
+        if not html_list:
+            return None
+
+        # Parse the main info page
+        tree = html.fromstring(html_list[0])
+        # Book name
+        book_name = self._first_str(tree.xpath('//div[@class="infos"]/h1/text()'))
+        # Tags: the second breadcrumb (e.g., "同人小说")
+        tag = self._first_str(
+            tree.xpath('//div[contains(@class,"menNav")]/a[2]/text()')
+        )
+        tags = [tag] if tag else []
+
+        author = self._first_str(tree.xpath('//div[@class="date"]/span[1]//a/text()'))
+        update_time = self._first_str(
+            tree.xpath('//div[@class="date"]/span[2]/text()'), replaces=[("时间：", "")]
+        )
+        cover_rel = self._first_str(tree.xpath('//div[@class="pic"]/img/@src'))
+        cover_url = (
+            f"{self.BASE_URL}{cover_rel}"
+            if cover_rel and not cover_rel.startswith("http")
+            else cover_rel
+        )
+
+        # Summary from the <p> inside infos
+        paras = tree.xpath('//div[@class="infos"]/p//text()')
+        summary = "\n".join(p.strip() for p in paras if p.strip())
+
+        # Chapters from the book_list
+        chapters: list[ChapterInfoDict] = []
+        for a in tree.xpath('//div[contains(@class,"book_list")]//li/a'):
+            url = a.get("href", "").strip()
+            title = a.text_content().strip()
+            # General regex: /{category}/{bookId}/{chapterId}.html
+            cid = url.split("/")[-1].split(".")[0]
+            chapters.append({"title": title, "url": url, "chapterId": cid})
+
+        volumes: list[VolumeInfoDict] = [{"volume_name": "正文", "chapters": chapters}]
+
+        # Parse the download page (second HTML)
+        download_url = ""
+        if len(html_list) > 1 and html_list[1]:
+            dtree = html.fromstring(html_list[1])
+            a = dtree.xpath('//a[@id="dowloadnUrl"]')
+            if a:
+                link = a[0].get("link") or a[0].get("href") or ""
+                download_url = self._fix_download_link(link)
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "tags": tags,
+            "summary": summary,
+            "volumes": volumes,
+            "extra": {"download_url": download_url},
+        }
+
+    def parse_chapter(
+        self,
+        html_list: list[str],
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> ChapterDict | None:
+        if not html_list:
+            return None
+
+        tree = html.fromstring(html_list[0])
+
+        raw_title = self._first_str(
+            tree.xpath('//div[contains(@class,"read_chapterName")]//h1/text()')
+        )
+
+        crumbs = tree.xpath('//div[contains(@class,"readTop")]//a/text()')
+        book_name = crumbs[-1].strip() if crumbs else ""
+
+        title = raw_title.replace(book_name, "").strip()
+
+        paragraphs = tree.xpath('//div[contains(@class,"read_chapterDetail")]/p')
+        texts = []
+        for p in paragraphs:
+            txt = p.text_content().strip()
+            if txt:
+                texts.append(txt)
+
+        content = "\n".join(texts)
+        if not content:
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "jpxs123"},
+        }
+
+    @classmethod
+    def _fix_download_link(cls, link: str) -> str:
+        true_link = link.replace("xs../", "/e/DownSys/")
+        return f"{cls.BASE_URL}{true_link}"

novel_downloader/core/parsers/lewenn.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.lewenn
+------------------------------------
+
+"""
+
+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 (
+    BookInfoDict,
+    ChapterDict,
+    ChapterInfoDict,
+    VolumeInfoDict,
+)
+
+
+@register_parser(
+    site_keys=["lewenn", "lewen"],
+)
+class LewennParser(BaseParser):
+    """
+    Parser for 乐文小说网 book pages.
+    """
+
+    BASE_URL = "https://www.lewenn.net"
+
+    ADS: set[str] = {
+        "app2",
+        "read2",
+        "chaptererror",
+        "记住乐文小说网",
+        "lewenn.net",
+    }
+
+    def parse_book_info(
+        self,
+        html_list: list[str],
+        **kwargs: Any,
+    ) -> BookInfoDict | None:
+        if not html_list:
+            return None
+
+        tree = html.fromstring(html_list[0])
+
+        # --- Metadata ---
+        book_name = self._first_str(tree.xpath('//div[@id="info"]/h1/text()'))
+        author = self._first_str(
+            tree.xpath('//div[@id="info"]/p[1]/text()'),
+            replaces=[(chr(0xA0), ""), ("作者：", "")],
+        )
+        serial_status = self._first_str(
+            tree.xpath('//div[@id="info"]/p[2]/text()'),
+            replaces=[(chr(0xA0), ""), ("状态：", "")],
+        )
+        update_time = self._first_str(
+            tree.xpath('//div[@id="info"]/p[3]/text()'),
+            replaces=[("最后更新：", "")],
+        )
+
+        cover_src = self._first_str(tree.xpath('//div[@id="sidebar"]//img/@src'))
+        cover_url = (
+            cover_src if cover_src.startswith("http") else f"{self.BASE_URL}{cover_src}"
+        )
+
+        summary_lines = tree.xpath('//div[@id="intro"]/p//text()')
+        summary = "\n".join(line.strip() for line in summary_lines).strip()
+
+        # --- Volumes & Chapters ---
+        chapters: list[ChapterInfoDict] = []
+        for dt in tree.xpath('//div[@class="listmain"]/dl/dt'):
+            title_text = dt.text_content().strip()
+            if "正文" in title_text:
+                # collect its <dd> siblings
+                sib = dt.getnext()
+                while sib is not None and sib.tag == "dd":
+                    a = sib.xpath(".//a")[0]
+                    chap_title = a.text_content().strip()
+                    href = a.get("href")
+                    url = href if href.startswith("http") else f"{self.BASE_URL}{href}"
+                    chap_id = url.rstrip(".html").split("/")[-1]
+                    chapters.append(
+                        {"title": chap_title, "url": url, "chapterId": chap_id}
+                    )
+                    sib = sib.getnext()
+                break
+
+        volumes: list[VolumeInfoDict] = [{"volume_name": "正文", "chapters": chapters}]
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "serial_status": serial_status,
+            "summary": summary,
+            "volumes": volumes,
+            "extra": {},
+        }
+
+    def parse_chapter(
+        self,
+        html_list: list[str],
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> ChapterDict | None:
+        if not html_list:
+            return None
+
+        tree = html.fromstring(html_list[0])
+
+        title = self._first_str(tree.xpath('//div[@class="content"]/h1/text()'))
+
+        nodes = tree.xpath('//div[@id="content" and contains(@class,"showtxt")]')
+        if not nodes:
+            return None
+        content_div = nodes[0]
+
+        raw_lines = [ln.strip() for ln in content_div.xpath(".//text()")]
+
+        lines: list[str] = []
+        for ln in raw_lines:
+            if not ln or self._is_ad_line(ln):
+                continue
+            # if ln.startswith("(") and ln.endswith(")"):
+            #     continue
+            lines.append(ln.replace(chr(0xA0), ""))
+
+        content = "\n".join(lines)
+        if not content.strip():
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "lewenn"},
+        }

novel_downloader/core/parsers/linovelib.py

@@ -7,23 +7,28 @@ novel_downloader.core.parsers.linovelib
 
 import json
 from itertools import islice
-from pathlib import PurePosixPath
 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
+from novel_downloader.models import (
+    BookInfoDict,
+    ChapterDict,
+    ChapterInfoDict,
+    VolumeInfoDict,
+)
 from novel_downloader.utils.constants import LINOVELIB_FONT_MAP_PATH
 
 
 @register_parser(
     site_keys=["linovelib"],
-    backends=["session", "browser"],
 )
 class LinovelibParser(BaseParser):
-    """ """
+    """
+    Parser for 哔哩轻小说 book pages.
+    """
 
     # Book info XPaths
     _BOOK_NAME_XPATH = '//div[@class="book-info"]/h1[@class="book-name"]/text()'
@@ -51,68 +56,69 @@ class LinovelibParser(BaseParser):
         self,
         html_list: list[str],
         **kwargs: Any,
-    ) -> dict[str, Any]:
-        """
-        Parse a book info page and extract metadata and chapter structure.
-
-        :param html_list: Raw HTML of the book info page.
-        :return: Parsed metadata and chapter structure as a dictionary.
-        """
+    ) -> BookInfoDict | None:
         if not html_list:
-            return {}
-        info_tree = html.fromstring(html_list[0])
-        result: dict[str, Any] = {}
-
-        result["book_name"] = self._safe_xpath(info_tree, self._BOOK_NAME_XPATH)
-        result["author"] = self._safe_xpath(info_tree, self._AUTHOR_XPATH)
-        result["cover_url"] = self._safe_xpath(info_tree, self._COVER_URL_XPATH)
-        result["update_time"] = self._safe_xpath(
-            info_tree, self._UPDATE_TIME_XPATH, replace=("最后更新：", "")
+            return None
+        tree = html.fromstring(html_list[0])
+
+        book_name = self._first_str(tree.xpath(self._BOOK_NAME_XPATH))
+        author = self._first_str(tree.xpath(self._AUTHOR_XPATH))
+        cover_url = self._first_str(tree.xpath(self._COVER_URL_XPATH))
+        update_time = self._first_str(
+            tree.xpath(self._UPDATE_TIME_XPATH), replaces=[("最后更新：", "")]
         )
-        result["serial_status"] = self._safe_xpath(info_tree, self._SERIAL_STATUS_XPATH)
-        result["word_count"] = self._safe_xpath(
-            info_tree, self._WORD_COUNT_XPATH, replace=("字数：", "")
+        serial_status = self._first_str(tree.xpath(self._SERIAL_STATUS_XPATH))
+        word_count = self._first_str(
+            tree.xpath(self._WORD_COUNT_XPATH), replaces=[("最后更新：", "")]
         )
 
-        result["summary"] = self._extract_intro(info_tree, self._SUMMARY_XPATH)
+        summary = self._extract_intro(tree, self._SUMMARY_XPATH)
 
         vol_pages = html_list[1:]
-        volumes: list[dict[str, Any]] = []
+        volumes: list[VolumeInfoDict] = []
         for vol_page in vol_pages:
             vol_tree = html.fromstring(vol_page)
-            volume_cover = self._safe_xpath(vol_tree, self._COVER_URL_XPATH)
-            volume_name = self._safe_xpath(vol_tree, self._BOOK_NAME_XPATH)
-            update_time = self._safe_xpath(
-                vol_tree, self._UPDATE_TIME_XPATH, replace=("最后更新：", "")
+            volume_cover = self._first_str(vol_tree.xpath(self._COVER_URL_XPATH))
+            volume_name = self._first_str(vol_tree.xpath(self._BOOK_NAME_XPATH))
+            vol_update_time = self._first_str(
+                vol_tree.xpath(self._UPDATE_TIME_XPATH), replaces=[("最后更新：", "")]
             )
-            word_count = self._safe_xpath(
-                vol_tree, self._WORD_COUNT_XPATH, replace=("字数：", "")
+            vol_word_count = self._first_str(
+                vol_tree.xpath(self._WORD_COUNT_XPATH), replaces=[("字数：", "")]
             )
             volume_intro = self._extract_intro(vol_tree, self._SUMMARY_XPATH)
 
-            chapters = []
+            chapters: list[ChapterInfoDict] = []
             chapter_elements = vol_tree.xpath(self._CHAPTERS_XPATH)
             for a in chapter_elements:
                 title = a.text.strip()
                 url = a.attrib.get("href", "").strip()
-                chap_path = PurePosixPath(url.rstrip("/"))
-                chapters.append(
-                    {"title": title, "url": url, "chapterId": chap_path.stem}
-                )
+                # '/novel/4668/276082.html' -> '276082'
+                cid = url.split("/")[-1].split(".")[0]
+                chapters.append({"title": title, "url": url, "chapterId": cid})
 
             volumes.append(
                 {
                     "volume_name": volume_name,
                     "volume_cover": volume_cover,
-                    "update_time": update_time,
-                    "word_count": word_count,
+                    "update_time": vol_update_time,
+                    "word_count": vol_word_count,
                     "volume_intro": volume_intro,
                     "chapters": chapters,
                 }
             )
-        result["volumes"] = volumes
 
-        return result
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "serial_status": serial_status,
+            "word_count": word_count,
+            "summary": summary,
+            "update_time": update_time,
+            "volumes": volumes,
+            "extra": {},
+        }
 
     def parse_chapter(
         self,
@@ -120,13 +126,6 @@ class LinovelibParser(BaseParser):
         chapter_id: str,
         **kwargs: Any,
     ) -> ChapterDict | None:
-        """
-        Parse chapter pages and extract clean text or simplified HTML.
-
-        :param html_list: Raw HTML of the chapter page.
-        :param chapter_id: Identifier of the chapter being parsed.
-        :return: Cleaned chapter content as plain text or minimal HTML.
-        """
         if not html_list:
             return None
         title_text: str = ""
@@ -170,25 +169,10 @@ class LinovelibParser(BaseParser):
         return {
             "id": chapter_id,
             "title": title_text,
-            "content": "\n\n".join(contents),
+            "content": "\n".join(contents),
             "extra": {"site": "linovelib"},
         }
 
-    def _safe_xpath(
-        self,
-        tree: html.HtmlElement,
-        path: str,
-        replace: tuple[str, str] | None = None,
-    ) -> str:
-        result = tree.xpath(path)
-        if not result:
-            return ""
-        value: str = result[0].strip()
-        if replace:
-            old, new = replace
-            value = value.replace(old, new)
-        return value
-
     @staticmethod
     def _extract_intro(tree: html.HtmlElement, xpath: str) -> str:
         paragraphs = tree.xpath(xpath.replace("//text()", ""))
@@ -197,7 +181,7 @@ class LinovelibParser(BaseParser):
             text_segments = p.xpath(".//text()")
             cleaned = [seg.strip() for seg in text_segments if seg.strip()]
             lines.append("\n".join(cleaned))
-        return "\n\n".join(lines)
+        return "\n".join(lines)
 
     @staticmethod
     def _is_encrypted(html: str) -> bool:

novel_downloader/core/parsers/piaotia.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.piaotia
+-------------------------------------
+
+"""
+
+import re
+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 (
+    BookInfoDict,
+    ChapterDict,
+    ChapterInfoDict,
+    VolumeInfoDict,
+)
+
+
+@register_parser(
+    site_keys=["piaotia"],
+)
+class PiaotiaParser(BaseParser):
+    """
+    Parser for 飘天文学网 book pages.
+    """
+
+    _RE_DEVICE_DIV = re.compile(
+        r'<div\s+id=[\'"“”]?device[\'"“”]?[^>]*>',
+        flags=re.IGNORECASE,
+    )
+
+    def parse_book_info(
+        self,
+        html_list: list[str],
+        **kwargs: Any,
+    ) -> BookInfoDict | None:
+        if len(html_list) < 2:
+            return None
+
+        # Parse trees
+        info_tree = html.fromstring(html_list[0])
+        catalog_tree = html.fromstring(html_list[1])
+
+        book_name = self._first_str(info_tree.xpath("//span[@style]//h1/text()"))
+        author = self._first_str(
+            info_tree.xpath(
+                '//td[contains(text(),"作") and contains(text(),"者")]/text()'
+            ),
+            replaces=[(chr(0xA0), ""), (" ", ""), ("作者：", "")],
+        )
+
+        # Category as tag
+        category = self._first_str(
+            info_tree.xpath(
+                '//td[contains(text(),"类") and contains(text(),"别")]/text()'
+            ),
+            replaces=[(chr(0xA0), ""), (" ", ""), ("类别：", "")],
+        )
+        tags = [category] if category else []
+
+        word_count = self._first_str(
+            info_tree.xpath('//td[contains(text(),"全文长度")]/text()'),
+            replaces=[(chr(0xA0), ""), (" ", ""), ("全文长度：", "")],
+        )
+
+        update_time = self._first_str(
+            info_tree.xpath('//td[contains(text(),"最后更新")]/text()'),
+            replaces=[(chr(0xA0), ""), (" ", ""), ("最后更新：", "")],
+        )
+
+        serial_status = self._first_str(
+            info_tree.xpath('//td[contains(text(),"文章状态")]/text()'),
+            replaces=[(chr(0xA0), ""), (" ", ""), ("文章状态：", "")],
+        )
+
+        cover_url = self._first_str(info_tree.xpath('//td[@width="80%"]//img/@src'))
+
+        # Summary
+        summary_divs = info_tree.xpath('//td[@width="80%"]/div')
+        if summary_divs:
+            raw = str(summary_divs[0].text_content())
+            summary = raw.split("内容简介：")[-1].strip()
+        else:
+            summary = ""
+
+        # Chapters (single volume)
+        chapters: list[ChapterInfoDict] = []
+        for a in catalog_tree.xpath('//div[@class="centent"]//ul/li/a'):
+            title = (a.text or "").strip()
+            url = a.get("href", "").strip()
+            chapter_id = url.split(".")[0]
+            chapters.append({"title": title, "url": url, "chapterId": chapter_id})
+
+        # Single volume
+        volumes: list[VolumeInfoDict] = [{"volume_name": "正文", "chapters": chapters}]
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "summary": summary,
+            "volumes": volumes,
+            "tags": tags,
+            "word_count": word_count,
+            "serial_status": serial_status,
+            "extra": {},
+        }
+
+    def parse_chapter(
+        self,
+        html_list: list[str],
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> ChapterDict | None:
+        """
+        Parse chapter page and extract the content of one chapter.
+
+        p.s. 结构好混乱:
+        1. `<head>` 没有对应的 `</head>`, 同理 `</body>` 没有对应的 `<body>`
+        2. 部分 html 通过 js 直接写入, 例如:
+            `document.write("<div id=\"main\" class=\"colors1 sidebar\">");`
+        3. 部分 div 的 id 或 style 属性周围的引号是非标准的波浪引号, 例如:
+            `<div id=”device” style=”background-color...”>`,
+            并也没有对应的 `</div>`
+
+        :param html_list: The HTML list of the chapter pages.
+        :param chapter_id: Identifier of the chapter being parsed.
+        :return: The chapter's data.
+        """
+        if not html_list:
+            return None
+
+        raw = self._RE_DEVICE_DIV.sub("", html_list[0])
+        raw = raw.replace(
+            '<script language="javascript">GetMode();</script>',
+            '<div id="main" class="colors1 sidebar">',
+        ).replace(
+            '<script language="javascript">GetFont();</script>',
+            '<div id="content">',
+        )
+
+        doc = html.fromstring(raw)
+        container = doc.xpath('//div[@id="content"]')
+        root = container[0] if container else doc
+
+        # Title comes straight from the <h1>
+        title = ""
+        h1 = root.find(".//h1")
+        if h1 is not None:
+            full = h1.text_content().strip()
+            a_txt = h1.xpath("./a/text()")
+            title = full.replace(a_txt[0].strip(), "").strip() if a_txt else full
+
+        # Walk the “script‑tables” -> <br> siblings for the body
+        table = root.xpath('.//table[@align="center" and @border]')
+        if not table:
+            return None
+        node = table[0].getnext()
+
+        lines: list[str] = []
+        while node is not None:
+            # stop at the next table or any bottom‑link nav div
+            if (node.tag == "table" and node.get("border")) or (
+                node.tag == "div" and node.get("class", "").endswith("link")
+            ):
+                break
+
+            if node.tag == "br":
+                txt = (node.tail or "").replace("\xa0", " ").strip()
+                if txt:
+                    lines.append(txt)
+
+            node = node.getnext()
+
+        content = "\n".join(lines).strip()
+        if not content:
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "piaotia"},
+        }