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

novel_downloader/core/parsers/ixdzs8.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.ixdzs8
+------------------------------------
+
+"""
+
+import contextlib
+import json
+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=["ixdzs8"],
+)
+class Ixdzs8Parser(BaseParser):
+    """
+    Parser for 爱下电子书 book pages.
+    """
+
+    def parse_book_info(
+        self,
+        html_list: list[str],
+        **kwargs: Any,
+    ) -> BookInfoDict | None:
+        if len(html_list) < 2 or not html_list[0] or not html_list[1]:
+            return None
+
+        # Parse HTML
+        tree = html.fromstring(html_list[0])
+
+        book_name = self._meta(tree, "og:novel:book_name") or self._first_str(
+            tree.xpath("//div[@class='n-text']/h1/text()")
+        )
+
+        author = self._meta(tree, "og:novel:author") or self._first_str(
+            tree.xpath("//div[@class='n-text']//a[contains(@class,'bauthor')]/text()")
+        )
+
+        cover_url = self._meta(tree, "og:image")
+        if not cover_url:
+            cover_url = self._first_str(tree.xpath("//div[@class='n-img']//img/@src"))
+
+        serial_status = self._meta(tree, "og:novel:status")
+
+        # 2022-08-25T18:08:03+08:00 -> 2022-08-25 18:08:03
+        iso_time = self._meta(tree, "og:novel:update_time")
+        update_time = ""
+        if iso_time:
+            update_time = iso_time.replace("T", " ").split("+", 1)[0].strip()
+
+        word_count = self._first_str(
+            tree.xpath("//div[@class='n-text']//span[contains(@class,'nsize')]/text()")
+        )
+
+        raw_summary = self._meta(tree, "og:description")
+        summary = ""
+        if raw_summary:
+            s = raw_summary.replace("&nbsp;", "")
+            s = s.replace("<br />", "\n")
+            summary = "\n".join(
+                self._norm_space(line) for line in s.splitlines()
+            ).strip()
+
+        tags = [
+            self._norm_space(t)
+            for t in tree.xpath("//div[contains(@class,'tags')]//em/a/text()")
+            if t and t.strip()
+        ]
+        category = self._meta(tree, "og:novel:category") or self._first_str(
+            tree.xpath("//div[@class='n-text']/p[a[contains(@class,'nsort')]]/a/text()")
+        )
+        if category:
+            tags.append(category)
+
+        book_path = self._meta(tree, "og:novel:read_url") or self._meta(tree, "og:url")
+        book_id = ""
+        if book_path:
+            book_id = book_path.strip("/").split("/")[-1]
+
+        data = {}
+        with contextlib.suppress(Exception):
+            data = json.loads(html_list[1])
+        clist = data.get("data", []) if isinstance(data, dict) else []
+
+        chapters: list[ChapterInfoDict] = []
+        for chap in clist:
+            ordernum = str(chap.get("ordernum", "")).strip()
+            if not ordernum:
+                continue
+            title = self._norm_space(chap.get("title", "") or "") or "未命名章节"
+            url = f"/read/{book_id}/p{ordernum}.html" if book_id else ""
+            chapters.append(
+                {
+                    "url": url,
+                    "title": title,
+                    "chapterId": f"p{ordernum}",
+                }
+            )
+
+        volumes: list[VolumeInfoDict] = [{"volume_name": "正文", "chapters": chapters}]
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "serial_status": serial_status,
+            "update_time": update_time,
+            "word_count": word_count,
+            "summary": summary,
+            "tags": tags,
+            "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='page-d-top']/h1/text()"))
+        if not title:
+            title = self._first_str(
+                tree.xpath("//article[contains(@class,'page-content')]//h3/text()")
+            )
+        title = self._norm_space(title)
+
+        # paragraphs within the reading section; skip ad containers
+        ps = tree.xpath(
+            "//article[contains(@class,'page-content')]//section//p[not(contains(@class,'abg'))]"
+        )
+
+        paragraphs: list[str] = []
+        for p in ps:
+            raw = p.text_content()
+            txt = self._norm_space(raw)
+            if not txt or self._is_ad_line(txt):
+                continue
+            paragraphs.append(txt)
+
+        if not paragraphs:
+            return None
+
+        # Replace FIRST line with .replace(title, "")
+        first = paragraphs[0].replace(title, "")
+        first = first.replace(title.replace(" ", ""), "").strip()
+        if first:
+            paragraphs[0] = first
+        else:
+            paragraphs.pop(0)
+
+        if paragraphs:
+            last = paragraphs[-1]
+            if "本章完" in last:
+                paragraphs.pop()
+
+        content = "\n".join(paragraphs)
+        if not content.strip():
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "ixdzs8"},
+        }
+
+    @classmethod
+    def _meta(cls, tree: html.HtmlElement, prop: str) -> str:
+        return cls._first_str(tree.xpath(f"//meta[@property='{prop}']/@content"))

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: