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

novel_downloader/core/parsers/guidaye.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.guidaye
+-------------------------------------
+
+"""
+
+import re
+from datetime import datetime
+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,
+    VolumeInfoDict,
+)
+
+
+@register_parser(
+    site_keys=["guidaye"],
+)
+class GuidayeParser(BaseParser):
+    """
+    Parser for 名著阅读 book pages.
+    """
+
+    BASE_URL = "https://b.guidaye.com"
+
+    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])
+
+        # Book metadata
+        book_name = self._first_str(tree.xpath('//h1[@class="page-title"]/a/text()'))
+        author = self._first_str(
+            tree.xpath('//div[@id="category-description-author"]/a/text()')
+        )
+        cover_url = self.BASE_URL + self._first_str(
+            tree.xpath('//div[@id="category-description-image"]//img/@src')
+        )
+
+        # Summary paragraphs
+        summary = (
+            tree.xpath('string(//div[@id="category-description-text"])')
+            .replace("内容简介：", "", 1)
+            .strip()
+        )
+
+        # Chapter volumes & listings
+        volumes: list[VolumeInfoDict] = []
+        curr_vol: VolumeInfoDict = {"volume_name": "未命名卷", "chapters": []}
+
+        items = tree.xpath('//div[@class="entry-content"]/ul/*')
+        for elem in items:
+            if elem.tag.lower() == "h3":
+                # Flush previous volume
+                if curr_vol["chapters"]:
+                    volumes.append(curr_vol)
+                curr_vol = {"volume_name": elem.text_content().strip(), "chapters": []}
+            elif elem.tag.lower() == "li":
+                link = elem.xpath(".//a")[0]
+                href = link.get("href", "").strip()
+                title = link.get("title", "").strip()
+                cid_match = re.search(r"/(\d+)\.html$", href)
+                chapter_id = cid_match.group(1) if cid_match else ""
+                curr_vol["chapters"].append(
+                    {"title": title, "url": href, "chapterId": chapter_id}
+                )
+
+        # Append last volume
+        if curr_vol["chapters"]:
+            volumes.append(curr_vol)
+
+        # Timestamp of parsing
+        share_text = tree.xpath('string(//div[@id="category-description-share"])')
+        m = re.search(r"最近更新[：:]\s*([\d-]+)", share_text)
+        update_time = m.group(1) if m else datetime.now().strftime("%Y-%m-%d")
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "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 from entry-title
+        title = self._first_str(tree.xpath('//h1[@class="entry-title"]/text()'))
+
+        # Extract paragraphs within entry-content
+        full_text = tree.xpath('string(//div[@class="entry-content"])')
+        full_text = full_text.replace("\u00A0", " ")
+
+        # 3. Split into lines and clean up
+        lines = [line.strip() for line in full_text.splitlines() if line.strip()]
+        if not lines:
+            return None
+
+        content = "\n".join(lines)
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "guidaye"},
+        }

novel_downloader/core/parsers/hetushu.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.hetushu
+-------------------------------------
+
+"""
+
+import re
+from datetime import datetime
+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,
+    VolumeInfoDict,
+)
+
+
+@register_parser(
+    site_keys=["hetushu"],
+)
+class HetushuParser(BaseParser):
+    """
+    Parser for 和图书 book pages.
+    """
+
+    BASE_URL = "https://www.hetushu.com"
+
+    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[contains(@class,"book_info")]/h2/text()')
+        )
+        author = self._first_str(
+            tree.xpath(
+                '//div[contains(@class,"book_info")]/div[contains(.,"作者")]/a/text()'
+            )
+        )
+        cover_url = self.BASE_URL + self._first_str(
+            tree.xpath('//div[contains(@class,"book_info")]//img/@src')
+        )
+
+        cls_attr = self._first_str(
+            tree.xpath('//div[contains(@class,"book_info")]/@class')
+        )
+        serial_status = "已完结" if "finish" in cls_attr else "连载中"
+
+        tags = [
+            a.strip()
+            for a in tree.xpath('//dl[@class="tag"]//dd/a/text()')
+            if a.strip()
+        ]
+
+        paras = tree.xpath('//div[@class="intro"]/p/text()')
+        summary = "\n".join(p.strip() for p in paras if p.strip())
+
+        # --- Chapter volumes & listings ---
+        volumes: list[VolumeInfoDict] = []
+        curr_vol: VolumeInfoDict = {"volume_name": "未命名卷", "chapters": []}
+
+        for elem in tree.xpath('//dl[@id="dir"]/*'):
+            if elem.tag == "dt":
+                # Start a new volume
+                if curr_vol["chapters"]:
+                    volumes.append(curr_vol)
+                curr_vol = {
+                    "volume_name": elem.text_content().strip(),
+                    "chapters": [],
+                }
+            elif elem.tag == "dd":
+                link = elem.xpath(".//a")[0]
+                href = link.get("href", "").strip()
+                title = link.get("title", "").strip()
+                # Extract numeric chapterId from the URL
+                m = re.search(r"/book/\d+/(?P<id>\d+)\.html", href)
+                chapter_id = m.group("id") if m else ""
+                curr_vol["chapters"].append(
+                    {"title": title, "url": href, "chapterId": chapter_id}
+                )
+
+        # Append the last volume if it has any chapters
+        if curr_vol["chapters"]:
+            volumes.append(curr_vol)
+
+        update_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "serial_status": serial_status,
+            "tags": tags,
+            "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[@id="content"]//h2[@class="h2"]/text()')
+        )
+
+        paras = tree.xpath('//div[@id="content"]/div[not(@class)]/text()')
+        paragraph_texts = [p.strip() for p in paras if p.strip()]
+
+        content = "\n".join(paragraph_texts)
+        if not content.strip():
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title,
+            "content": content,
+            "extra": {"site": "hetushu"},
+        }

novel_downloader/core/parsers/i25zw.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.i25zw
+-----------------------------------
+
+"""
+
+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=["i25zw"],
+)
+class I25zwParser(BaseParser):
+    """
+    Parser for 25中文网 book-info pages.
+    """
+
+    def parse_book_info(
+        self,
+        html_list: list[str],
+        **kwargs: Any,
+    ) -> BookInfoDict | None:
+        if len(html_list) < 2:
+            return None
+
+        info_tree = html.fromstring(html_list[0])
+        catalog_tree = html.fromstring(html_list[1])
+
+        # Metadata extraction
+        book_name = self._first_str(info_tree.xpath("//h1[@class='f21h']/text()"))
+        author = self._first_str(info_tree.xpath("//h1[@class='f21h']/em/a/text()"))
+        cover_url = self._first_str(info_tree.xpath("//div[@class='pic']/img/@src"))
+
+        # Tags, status, word count, update time
+        tag = self._first_str(
+            info_tree.xpath("//b[contains(text(),'小说分类')]/parent::td/text()")
+        )
+        serial_status = self._first_str(
+            info_tree.xpath("//b[contains(text(),'小说状态')]/parent::td/text()")
+        )
+        word_count = self._first_str(
+            info_tree.xpath("//b[contains(text(),'全文字数')]/parent::td/text()")
+        )
+        raw_update = self._first_str(
+            info_tree.xpath("//b[contains(text(),'更新时间')]/parent::td/text()")
+        )
+        update_time = raw_update.strip("()")
+
+        # Summary from styled intro div
+        full_intro = info_tree.xpath("string(//div[@class='intro'][@style])").strip()
+        summary = full_intro.replace(f"关于{book_name}：", "", 1).strip()
+
+        # Chapter list extraction
+        dl = catalog_tree.xpath("//div[@id='list']/dl")[0]
+        # Full-text section dd's
+        dds = dl.xpath("./dd[preceding-sibling::dt[1][contains(., '正文')]]/a")
+        if not dds:
+            # Fallback to second <dt>'s following <dd>
+            dds = dl.xpath("./dt[2]/following-sibling::dd/a")
+
+        chapters: list[ChapterInfoDict] = []
+        for a in dds:
+            url = a.get("href", "").strip()
+            title = a.text_content().strip()
+            # '/311006/252845677.html' -> '252845677'
+            chapter_id = url.split("/")[-1].split(".")[0]
+            chapters.append(
+                {
+                    "title": title,
+                    "url": url,
+                    "chapterId": chapter_id,
+                }
+            )
+        volumes: list[VolumeInfoDict] = [{"volume_name": "正文", "chapters": chapters}]
+
+        return {
+            "book_name": book_name,
+            "author": author,
+            "cover_url": cover_url,
+            "update_time": update_time,
+            "word_count": word_count,
+            "serial_status": serial_status,
+            "tags": [tag] if tag else [],
+            "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_text = self._first_str(
+            tree.xpath("//div[@class='zhangjieming']/h1/text()")
+        )
+
+        content_divs = tree.xpath("//div[@id='content']")
+        if not content_divs:
+            return None
+        content_div = content_divs[0]
+
+        # Only select direct <p> children to avoid nav links
+        paragraphs = []
+        for p in content_div.xpath("./p"):
+            text = p.text_content().strip()
+            if text:
+                paragraphs.append(text)
+
+        content_text = "\n".join(paragraphs)
+        if not content_text.strip():
+            return None
+
+        return {
+            "id": chapter_id,
+            "title": title_text,
+            "content": content_text,
+            "extra": {"site": "i25zw"},
+        }

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"))