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

novel_downloader/core/searchers/esjzone.py

@@ -21,63 +21,81 @@ logger = logging.getLogger(__name__)
 )
 class EsjzoneSearcher(BaseSearcher):
     site_name = "esjzone"
-    priority = 3
+    priority = 30
+    BASE_URL = "https://www.esjzone.cc"
     SEARCH_URL = "https://www.esjzone.cc/tags/{query}/"
 
     @classmethod
-    def _fetch_html(cls, keyword: str) -> str:
-        """
-        Fetch raw HTML from Esjzone's search page.
-
-        :param keyword: The search term to query on Esjzone.
-        :return: HTML text of the search results page, or an empty string on fail.
-        """
+    async def _fetch_html(cls, keyword: str) -> str:
         url = cls.SEARCH_URL.format(query=cls._quote(keyword))
         try:
-            response = cls._http_get(url)
-            return response.text
+            async with (await cls._http_get(url)) as resp:
+                return await cls._response_to_str(resp)
         except Exception:
             logger.error(
                 "Failed to fetch HTML for keyword '%s' from '%s'",
                 keyword,
                 url,
-                exc_info=True,
             )
             return ""
 
     @classmethod
     def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
-        """
-        Parse raw HTML from Esjzone search results into list of SearchResult.
-
-        :param html_str: Raw HTML string from Esjzone search results page.
-        :param limit: Maximum number of results to return, or None for all.
-        :return: List of SearchResult dicts.
-        """
         doc = html.fromstring(html_str)
         cards = doc.xpath('//div[contains(@class,"card-body")]')
         results: list[SearchResult] = []
 
         for idx, card in enumerate(cards):
+            href = cls._first_str(
+                card.xpath(".//h5[contains(@class,'card-title')]/a[1]/@href")
+            )
+            if not href:
+                continue
+
             if limit is not None and idx >= limit:
                 break
-            # Title and book_id
-            link = card.xpath('.//h5[@class="card-title"]/a')[0]
-            title = link.text_content().strip()
-            href = link.get("href", "")
+
             # href format: /detail/<book_id>.html
-            book_id = href.strip("/").replace("detail/", "").replace(".html", "")
+            book_id = href.split("/")[-1].split(".")[0]
+            book_url = cls._abs_url(href)
+
+            title = cls._first_str(
+                card.xpath(".//h5[contains(@class,'card-title')]/a[1]//text()")
+            )
+
+            latest_chapter = (
+                cls._first_str(
+                    card.xpath(".//div[contains(@class,'card-ep')]//a[1]//text()")
+                )
+                or "-"
+            )
+
             # Author
-            author_link = card.xpath('.//div[@class="card-author"]/a')[0]
-            author = author_link.text_content().strip()
+            author = cls._first_str(
+                card.xpath(".//div[contains(@class,'card-author')]//a[1]//text()")
+            ) or cls._first_str(
+                card.xpath(".//div[contains(@class,'card-author')]//text()")
+            )
+
+            cover_data = card.xpath(
+                './preceding-sibling::a[contains(@class,"card-img-tiles")]'
+                '//div[contains(@class,"lazyload")]/@data-src'
+            )
+            cover_url = cover_data[0].strip() if cover_data else ""
+
             # Compute priority incrementally
             prio = cls.priority + idx
             results.append(
                 SearchResult(
                     site=cls.site_name,
                     book_id=book_id,
+                    book_url=book_url,
+                    cover_url=cover_url,
                     title=title,
                     author=author,
+                    latest_chapter=latest_chapter,
+                    update_date="-",
+                    word_count="-",
                     priority=prio,
                 )
             )

novel_downloader/core/searchers/hetushu.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.hetushu
+---------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["hetushu"],
+)
+class HetushuSearcher(BaseSearcher):
+    site_name = "hetushu"
+    priority = 5
+    SEARCH_URL = "https://www.hetushu.com/search/"
+    BASE_URL = "https://www.hetushu.com"
+
+    @classmethod
+    async def _fetch_html(cls, keyword: str) -> str:
+        params = {"keyword": keyword}
+        headers = {
+            "Referer": "https://www.hetushu.com/",
+        }
+        try:
+            async with (
+                await cls._http_get(cls.SEARCH_URL, params=params, headers=headers)
+            ) as resp:
+                return await cls._response_to_str(resp)
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        doc = html.fromstring(html_str)
+        rows = doc.xpath('//dl[@class="list" and @id="body"]/dd')
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            href = cls._first_str(row.xpath(".//h4/a/@href"))
+            if not href:
+                continue
+
+            if limit is not None and idx >= limit:
+                break
+
+            # "/book/7631/index.html" -> "7631"
+            book_id = href.rstrip("/index.html").split("/")[-1]
+            book_url = cls._abs_url(href)
+
+            title = cls._first_str(row.xpath(".//h4/a/text()"))
+
+            # Author from the adjacent <span>, strip "/" delimiters
+            # e.x. " / 风行云亦行 / "
+            author_raw = cls._first_str(row.xpath(".//h4/span/text()"))
+            author = author_raw.strip("/").strip()
+
+            cover_rel = cls._first_str(row.xpath(".//a/img/@src"))
+            cover_url = cls._abs_url(cover_rel) if cover_rel else ""
+
+            # Compute priority
+            prio = cls.priority + idx
+
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    book_url=book_url,
+                    cover_url=cover_url,
+                    title=title,
+                    author=author,
+                    latest_chapter="-",
+                    update_date="-",
+                    word_count="-",
+                    priority=prio,
+                )
+            )
+        return results

novel_downloader/core/searchers/i25zw.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.i25zw
+-------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["i25zw"],
+)
+class I25zwSearcher(BaseSearcher):
+    site_name = "i25zw"
+    priority = 30
+    SEARCH_URL = "https://www.i25zw.com/search.html"
+
+    @classmethod
+    async def _fetch_html(cls, keyword: str) -> str:
+        payload = {
+            "searchkey": keyword,
+            "searchtype": "all",
+            "Submit": "",
+        }
+        try:
+            async with (await cls._http_post(cls.SEARCH_URL, data=payload)) as resp:
+                return await cls._response_to_str(resp)
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        doc = html.fromstring(html_str)
+        rows = doc.xpath("//div[@id='alistbox']")
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            book_url = cls._first_str(row.xpath(".//div[@class='pic']/a/@href"))
+            if not book_url:
+                continue
+
+            if limit is not None and idx >= limit:
+                break
+
+            # 'https://www.i25zw.com/book/309209.html' -> "309209"
+            book_id = book_url.split("/")[-1].split(".")[0]
+
+            title = cls._first_str(row.xpath(".//div[@class='title']/h2/a/text()"))
+
+            author = cls._first_str(
+                row.xpath(".//div[@class='title']/span/text()"),
+                replaces=[("作者：", "")],
+            )
+
+            cover_rel = cls._first_str(row.xpath(".//div[@class='pic']//img/@src"))
+            cover_url = cls._abs_url(cover_rel) if cover_rel else ""
+
+            # Latest chapter
+            latest_chapter = (
+                cls._first_str(row.xpath(".//div[@class='sys']//li[1]/a/text()")) or "-"
+            )
+
+            prio = cls.priority + idx
+
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    book_url=book_url,
+                    cover_url=cover_url,
+                    title=title,
+                    author=author,
+                    latest_chapter=latest_chapter,
+                    update_date="-",
+                    word_count="-",
+                    priority=prio,
+                )
+            )
+        return results

novel_downloader/core/searchers/ixdzs8.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.ixdzs8
+--------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["ixdzs8"],
+)
+class Ixdzs8Searcher(BaseSearcher):
+    site_name = "ixdzs8"
+    priority = 30
+    BASE_URL = "https://ixdzs8.com"
+    SEARCH_URL = "https://ixdzs8.com/bsearch"
+
+    @classmethod
+    async def _fetch_html(cls, keyword: str) -> str:
+        params = {"q": keyword}
+        try:
+            async with (await cls._http_get(cls.SEARCH_URL, params=params)) as resp:
+                return await cls._response_to_str(resp)
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        doc = html.fromstring(html_str)
+        rows = doc.xpath("//ul[contains(@class,'u-list')]/li[contains(@class,'burl')]")
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            book_path = cls._first_str(row.xpath("./@data-url"))
+            if not book_path:
+                book_path = cls._first_str(
+                    row.xpath(".//h3[contains(@class,'bname')]/a/@href")
+                )
+            if not book_path:
+                continue
+
+            if limit is not None and idx >= limit:
+                break
+
+            book_id = book_path.strip("/").split("/")[-1]
+            book_url = cls._abs_url(book_path)
+
+            cover_rel = cls._first_str(
+                row.xpath(".//div[contains(@class,'l-img')]//img/@src")
+            )
+            cover_url = cls._abs_url(cover_rel) if cover_rel else ""
+
+            title = cls._first_str(
+                row.xpath(".//h3[contains(@class,'bname')]/a/@title")
+            ) or cls._first_str(row.xpath(".//h3[contains(@class,'bname')]/a/text()"))
+
+            author = cls._first_str(
+                row.xpath(".//span[contains(@class,'bauthor')]//a/text()")
+            )
+            word_count = cls._first_str(
+                row.xpath(".//span[contains(@class,'size')]/text()")
+            )
+
+            latest_chapter = cls._first_str(
+                row.xpath(
+                    ".//p[contains(@class,'l-last')]//span[contains(@class,'l-chapter')]/text()"
+                )
+            )
+            update_date = cls._first_str(
+                row.xpath(
+                    ".//p[contains(@class,'l-last')]//span[contains(@class,'l-time')]/text()"
+                )
+            )
+
+            # Compute priority
+            prio = cls.priority + idx
+
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    book_url=book_url,
+                    cover_url=cover_url,
+                    title=title,
+                    author=author,
+                    latest_chapter=latest_chapter,
+                    update_date=update_date,
+                    word_count=word_count,
+                    priority=prio,
+                )
+            )
+        return results

novel_downloader/core/searchers/jpxs123.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.jpxs123
+---------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["jpxs123"],
+)
+class Jpxs123Searcher(BaseSearcher):
+    site_name = "jpxs123"
+    priority = 30
+    BASE_URL = "https://www.jpxs123.com"
+    SEARCH_URL = "https://www.jpxs123.com/e/search/indexsearch.php"
+
+    @classmethod
+    async def _fetch_html(cls, keyword: str) -> str:
+        keyboard = cls._quote(keyword, encoding="gbk", errors="replace")
+        show = "title"
+        classid = "0"
+        body = f"keyboard={keyboard}&show={show}&classid={classid}"
+        headers = {
+            "Origin": "https://www.jpxs123.com",
+            "Referer": "https://www.jpxs123.com/",
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+        try:
+            async with (
+                await cls._http_post(cls.SEARCH_URL, data=body, headers=headers)
+            ) as resp:
+                return await cls._response_to_str(resp)
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        doc = html.fromstring(html_str)
+        rows = doc.xpath('//div[@class="books m-cols"]/div[@class="bk"]')
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            href = cls._first_str(row.xpath(".//h3/a/@href"))
+            if not href:
+                continue
+
+            if limit is not None and idx >= limit:
+                break
+
+            book_id = href.strip("/").split(".", 1)[0].replace("/", "-")
+            book_url = cls._abs_url(href)
+
+            title = cls._first_str(row.xpath(".//h3/a//text()"))
+
+            cover_rel = cls._first_str(
+                row.xpath(".//div[contains(@class,'pic')]//a//img/@src")
+            )
+            cover_url = cls._abs_url(cover_rel) if cover_rel else ""
+
+            author = (
+                cls._first_str(
+                    row.xpath(".//div[contains(@class,'booknews')]/text()"),
+                    replaces=[("作者：", "")],
+                )
+                or "-"
+            )
+
+            update_date = cls._first_str(
+                row.xpath(
+                    ".//div[contains(@class,'booknews')]/label[contains(@class,'date')]/text()"
+                )
+            )
+
+            # Compute priority
+            prio = cls.priority + idx
+
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    book_url=book_url,
+                    cover_url=cover_url,
+                    title=title,
+                    author=author,
+                    latest_chapter="-",
+                    update_date=update_date,
+                    word_count="-",
+                    priority=prio,
+                )
+            )
+        return results

novel_downloader/core/searchers/piaotia.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.searchers.piaotia
+---------------------------------------
+
+"""
+
+import logging
+
+from lxml import html
+
+from novel_downloader.core.searchers.base import BaseSearcher
+from novel_downloader.core.searchers.registry import register_searcher
+from novel_downloader.models import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+@register_searcher(
+    site_keys=["piaotia"],
+)
+class PiaotiaSearcher(BaseSearcher):
+    site_name = "piaotia"
+    priority = 30
+    SEARCH_URL = "https://www.piaotia.com/modules/article/search.php"
+
+    @classmethod
+    async def _fetch_html(cls, keyword: str) -> str:
+        # data = {
+        #     "searchtype": "articlename",
+        #     # "searchtype": "author",
+        #     # "searchtype": "keywords",
+        #     "searchkey": cls._quote(keyword, encoding="gbk", errors='replace'),
+        #     "Submit": cls._quote(" 搜 索 ", encoding="gbk", errors='replace'),
+        # }
+        searchtype = "articlename"
+        searchkey = cls._quote(keyword, encoding="gbk", errors="replace")
+        submit = cls._quote(" 搜 索 ", encoding="gbk", errors="replace")
+        body = f"searchtype={searchtype}&searchkey={searchkey}&Submit={submit}"
+        headers = {
+            "Origin": "https://www.piaotia.com",
+            "Referer": "https://www.piaotia.com",
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+        try:
+            async with (
+                await cls._http_post(cls.SEARCH_URL, data=body, headers=headers)
+            ) as resp:
+                return await cls._response_to_str(resp, encoding="gbk")
+        except Exception:
+            logger.error(
+                "Failed to fetch HTML for keyword '%s' from '%s'",
+                keyword,
+                cls.SEARCH_URL,
+            )
+            return ""
+
+    @classmethod
+    def _parse_html(cls, html_str: str, limit: int | None = None) -> list[SearchResult]:
+        doc = html.fromstring(html_str)
+        rows = doc.xpath('//table[@class="grid"]//tr[td]')
+        results: list[SearchResult] = []
+
+        for idx, row in enumerate(rows):
+            href = cls._first_str(row.xpath("./td[1]/a[1]/@href"))
+            if not href:
+                continue
+
+            if limit is not None and idx >= limit:
+                break
+
+            # "https://www.piaotia.com/bookinfo/14/14767.html" -> "14-14767"
+            book_id = href.rstrip(".html").split("bookinfo/")[-1].replace("/", "-")
+            book_url = cls._abs_url(href)
+
+            title = cls._first_str(row.xpath("./td[1]/a[1]//text()"))
+
+            latest_chapter = cls._first_str(row.xpath("./td[2]/a[1]//text()")) or "-"
+
+            author = cls._first_str(row.xpath("./td[3]//text()")) or "-"
+            word_count = cls._first_str(row.xpath("./td[4]//text()")) or "-"
+            update_date = cls._first_str(row.xpath("./td[5]//text()")) or "-"
+
+            # Compute priority incrementally
+            prio = cls.priority + idx
+            results.append(
+                SearchResult(
+                    site=cls.site_name,
+                    book_id=book_id,
+                    book_url=book_url,
+                    cover_url="",
+                    title=title,
+                    author=author,
+                    latest_chapter=latest_chapter,
+                    update_date=update_date,
+                    word_count=word_count,
+                    priority=prio,
+                )
+            )
+        return results