novel-downloader 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

novel_downloader/core/{requesters/common/async_session.py → fetchers/common/session.py}

@@ -1,42 +1,30 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters.common.async_session
------------------------------------------------------
+novel_downloader.core.fetchers.common.session
+---------------------------------------------
 
-This module defines a `CommonAsyncSession` class for handling HTTP requests
-to common novel sites **asynchronously**. It provides methods to retrieve
-raw book info pages and chapter contents using a flexible URL templating
-system defined by a site profile, with retry logic and random delays.
 """
 
 from typing import Any
 
-from novel_downloader.config import RequesterConfig, SiteProfile
-from novel_downloader.core.requesters.base import BaseAsyncSession
+from novel_downloader.core.fetchers.base import BaseSession
+from novel_downloader.models import FetcherConfig, SiteProfile
 
 
-class CommonAsyncSession(BaseAsyncSession):
+class CommonSession(BaseSession):
     """
     A common async session for handling site-specific HTTP requests.
     """
 
     def __init__(
         self,
-        config: RequesterConfig,
         site: str,
         profile: SiteProfile,
+        config: FetcherConfig,
         cookies: dict[str, str] | None = None,
+        **kwargs: Any,
     ) -> None:
-        """
-        Initialize a CommonAsyncSession instance.
-
-        :param config: The RequesterConfig instance containing settings.
-        :param site: The identifier or domain of the target site.
-        :param profile: The site's metadata and URL templates.
-        :param cookies: Optional cookies to preload into the session.
-        """
-        super().__init__(config, cookies)
-        self._site = site
+        super().__init__(site, config, cookies, **kwargs)
         self._profile = profile
 
     async def get_book_info(
@@ -69,11 +57,6 @@ class CommonAsyncSession(BaseAsyncSession):
         url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
         return [await self.fetch(url, **kwargs)]
 
-    @property
-    def site(self) -> str:
-        """Return the site name."""
-        return self._site
-
     def book_info_url(self, book_id: str) -> str:
         """
         Construct the URL for fetching a book's info page.

novel_downloader/core/fetchers/esjzone/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.esjzone
+--------------------------------------
+
+"""
+
+from .browser import EsjzoneBrowser
+from .session import EsjzoneSession
+
+__all__ = [
+    "EsjzoneBrowser",
+    "EsjzoneSession",
+]

novel_downloader/core/fetchers/esjzone/browser.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.esjzone.browser
+----------------------------------------------
+
+"""
+
+from typing import Any
+
+from novel_downloader.core.fetchers.base import BaseBrowser
+from novel_downloader.models import FetcherConfig, LoginField
+
+
+class EsjzoneBrowser(BaseBrowser):
+    """
+    A browser class for interacting with the Esjzone (www.esjzone.cc) novel website.
+    """
+
+    BOOKCASE_URL = "https://www.esjzone.cc/my/favorite"
+    BOOK_INFO_URL = "https://www.esjzone.cc/detail/{book_id}.html"
+    CHAPTER_URL = "https://www.esjzone.cc/forum/{book_id}/{chapter_id}.html"
+
+    API_LOGIN_URL_1 = "https://www.esjzone.cc/my/login"
+    API_LOGIN_URL_2 = "https://www.esjzone.cc/inc/mem_login.php"
+
+    def __init__(
+        self,
+        config: FetcherConfig,
+        reuse_page: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("esjzone", config, reuse_page, **kwargs)
+
+    async def login(
+        self,
+        username: str = "",
+        password: str = "",
+        cookies: dict[str, str] | None = None,
+        attempt: int = 1,
+        **kwargs: Any,
+    ) -> bool:
+        self._is_logged_in = await self._check_login_status()
+        if self._is_logged_in:
+            return True
+
+        if not (username and password):
+            self.logger.warning("[auth] No credentials provided.")
+            return False
+
+        login_page = await self.context.new_page()
+
+        await login_page.goto(self.API_LOGIN_URL_1, wait_until="networkidle")
+
+        await login_page.fill('input[name="email"]', username)
+        await login_page.fill('input[name="pwd"]', password)
+
+        await login_page.click('a.btn-send[data-send="mem_login"]')
+
+        await login_page.wait_for_load_state("networkidle")
+        await login_page.close()
+
+        self._is_logged_in = await self._check_login_status()
+
+        return self._is_logged_in
+
+    async def get_book_info(
+        self,
+        book_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of the book info page asynchronously.
+
+        :param book_id: The book identifier.
+        :return: The page content as a string.
+        """
+        url = self.book_info_url(book_id=book_id)
+        return [await self.fetch(url, **kwargs)]
+
+    async def get_book_chapter(
+        self,
+        book_id: str,
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of a single chapter asynchronously.
+
+        :param book_id: The book identifier.
+        :param chapter_id: The chapter identifier.
+        :return: The chapter content as a string.
+        """
+        url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
+        return [await self.fetch(url, **kwargs)]
+
+    async def get_bookcase(
+        self,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Retrieve the user's *bookcase* page.
+
+        :return: The HTML markup of the bookcase page.
+        """
+        url = self.bookcase_url()
+        return [await self.fetch(url, **kwargs)]
+
+    async def set_interactive_mode(self, enable: bool) -> bool:
+        """
+        Enable or disable interactive mode for manual login.
+
+        :param enable: True to enable, False to disable interactive mode.
+        :return: True if operation or login check succeeded, False otherwise.
+        """
+        if enable:
+            if self.headless:
+                await self._restart_browser(headless=False)
+            if self._manual_page is None:
+                self._manual_page = await self.context.new_page()
+            await self._manual_page.goto(self.API_LOGIN_URL_1)
+            return True
+
+        # restore
+        if self._manual_page:
+            await self._manual_page.close()
+        self._manual_page = None
+        if self.headless:
+            await self._restart_browser(headless=True)
+            self._is_logged_in = await self._check_login_status()
+        return self.is_logged_in
+
+    @property
+    def login_fields(self) -> list[LoginField]:
+        return [
+            LoginField(
+                name="username",
+                label="用户名",
+                type="text",
+                required=True,
+                placeholder="请输入你的用户名",
+                description="用于登录 esjzone.cc 的用户名",
+            ),
+            LoginField(
+                name="password",
+                label="密码",
+                type="password",
+                required=True,
+                placeholder="请输入你的密码",
+                description="用于登录 esjzone.cc 的密码",
+            ),
+        ]
+
+    @classmethod
+    def bookcase_url(cls) -> str:
+        """
+        Construct the URL for the user's bookcase page.
+
+        :return: Fully qualified URL of the bookcase.
+        """
+        return cls.BOOKCASE_URL
+
+    @classmethod
+    def book_info_url(cls, book_id: str) -> str:
+        """
+        Construct the URL for fetching a book's info page.
+
+        :param book_id: The identifier of the book.
+        :return: Fully qualified URL for the book info page.
+        """
+        return cls.BOOK_INFO_URL.format(book_id=book_id)
+
+    @classmethod
+    def chapter_url(cls, book_id: str, chapter_id: str) -> str:
+        """
+        Construct the URL for fetching a specific chapter.
+
+        :param book_id: The identifier of the book.
+        :param chapter_id: The identifier of the chapter.
+        :return: Fully qualified chapter URL.
+        """
+        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
+
+    async def _check_login_status(self) -> bool:
+        """
+        Check whether the user is currently logged in by
+        inspecting the bookcase page content.
+
+        :return: True if the user is logged in, False otherwise.
+        """
+        keywords = [
+            "window.location.href='/my/login'",
+            "會員登入",
+            "會員註冊 SIGN UP",
+        ]
+        resp_text = await self.get_bookcase()
+        if not resp_text:
+            return False
+        return not any(kw in resp_text[0] for kw in keywords)
+
+    @property
+    def hostname(self) -> str:
+        return "www.esjzone.cc"

novel_downloader/core/{requesters/esjzone/async_session.py → fetchers/esjzone/session.py}

@@ -1,24 +1,21 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters.esjzone.async_session
-------------------------------------------------------
+novel_downloader.core.fetchers.esjzone.session
+----------------------------------------------
 
 """
 
 import re
 from typing import Any
 
-from novel_downloader.config.models import RequesterConfig
-from novel_downloader.core.requesters.base import BaseAsyncSession
-from novel_downloader.utils.i18n import t
-from novel_downloader.utils.state import state_mgr
+from novel_downloader.core.fetchers.base import BaseSession
+from novel_downloader.models import FetcherConfig, LoginField
 from novel_downloader.utils.time_utils import async_sleep_with_random_delay
 
 
-class EsjzoneAsyncSession(BaseAsyncSession):
+class EsjzoneSession(BaseSession):
     """
-    A async session class for interacting with the
-    esjzone (www.esjzone.cc) novel website.
+    A session class for interacting with the esjzone (www.esjzone.cc) novel website.
     """
 
     BOOKCASE_URL = "https://www.esjzone.cc/my/favorite"
@@ -30,45 +27,50 @@ class EsjzoneAsyncSession(BaseAsyncSession):
 
     def __init__(
         self,
-        config: RequesterConfig,
-    ):
-        super().__init__(config)
-        self._logged_in: bool = False
-        self._request_interval = config.backoff_factor
-        self._retry_times = config.retry_times
-        self._username = config.username
-        self._password = config.password
+        config: FetcherConfig,
+        cookies: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("esjzone", config, cookies, **kwargs)
 
     async def login(
         self,
         username: str = "",
         password: str = "",
-        manual_login: bool = False,
+        cookies: dict[str, str] | None = None,
+        attempt: int = 1,
         **kwargs: Any,
     ) -> bool:
         """
         Restore cookies persisted by the session-based workflow.
         """
-        cookies: dict[str, str] = state_mgr.get_cookies("esjzone")
-        username = username or self._username
-        password = password or self._password
+        if cookies:
+            self.update_cookies(cookies)
+
+        if await self._check_login_status():
+            self._is_logged_in = True
+            self.logger.debug("[auth] Logged in via cookies.")
+            return True
+
+        if not (username and password):
+            self.logger.warning("[auth] No credentials provided.")
+            return False
 
-        self.update_cookies(cookies)
-        for _ in range(self._retry_times):
-            if await self._check_login_status():
-                self.logger.debug("[auth] Already logged in.")
-                self._logged_in = True
+        for _ in range(attempt):
+            if (
+                await self._api_login(username, password)
+                and await self._check_login_status()
+            ):
+                self._is_logged_in = True
                 return True
-            if username and password and not await self._api_login(username, password):
-                print(t("session_login_failed", site="esjzone"))
             await async_sleep_with_random_delay(
-                self._request_interval,
+                self.backoff_factor,
                 mul_spread=1.1,
-                max_sleep=self._request_interval + 2,
+                max_sleep=self.backoff_factor + 2,
             )
 
-        self._logged_in = await self._check_login_status()
-        return self._logged_in
+        self._is_logged_in = False
+        return False
 
     async def get_book_info(
         self,
@@ -78,8 +80,6 @@ class EsjzoneAsyncSession(BaseAsyncSession):
         """
         Fetch the raw HTML of the book info page asynchronously.
 
-        Order: [info, catalog]
-
         :param book_id: The book identifier.
         :return: The page content as a string.
         """
@@ -104,7 +104,6 @@ class EsjzoneAsyncSession(BaseAsyncSession):
 
     async def get_bookcase(
         self,
-        page: int = 1,
         **kwargs: Any,
     ) -> list[str]:
         """
@@ -115,6 +114,27 @@ class EsjzoneAsyncSession(BaseAsyncSession):
         url = self.bookcase_url()
         return [await self.fetch(url, **kwargs)]
 
+    @property
+    def login_fields(self) -> list[LoginField]:
+        return [
+            LoginField(
+                name="username",
+                label="用户名",
+                type="text",
+                required=True,
+                placeholder="请输入你的用户名",
+                description="用于登录 esjzone.cc 的用户名",
+            ),
+            LoginField(
+                name="password",
+                label="密码",
+                type="password",
+                required=True,
+                placeholder="请输入你的密码",
+                description="用于登录 esjzone.cc 的密码",
+            ),
+        ]
+
     @classmethod
     def bookcase_url(cls) -> str:
         """
@@ -145,6 +165,10 @@ class EsjzoneAsyncSession(BaseAsyncSession):
         """
         return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
 
+    @property
+    def hostname(self) -> str:
+        return "www.esjzone.cc"
+
     async def _api_login(self, username: str, password: str) -> bool:
         """
         Login to the API using a 2-step token-based process.
@@ -178,7 +202,7 @@ class EsjzoneAsyncSession(BaseAsyncSession):
                 self.API_LOGIN_URL_2, data=data_2, headers=temp_headers
             )
             resp_2.raise_for_status()
-            json_2 = await resp_2.json()
+            json_2 = await resp_2.json(content_type="text/html", encoding="utf-8")
             resp_code: int = json_2.get("status", 301)
             return resp_code == 200
         except Exception as exc:
@@ -194,6 +218,8 @@ class EsjzoneAsyncSession(BaseAsyncSession):
         """
         keywords = [
             "window.location.href='/my/login'",
+            "會員登入",
+            "會員註冊 SIGN UP",
         ]
         resp_text = await self.get_bookcase()
         if not resp_text:
@@ -203,9 +229,3 @@ class EsjzoneAsyncSession(BaseAsyncSession):
     def _extract_token(self, text: str) -> str:
         match = re.search(r"<JinJing>(.+?)</JinJing>", text)
         return match.group(1) if match else ""
-
-    async def _on_close(self) -> None:
-        """
-        Save cookies to the state manager before closing.
-        """
-        state_mgr.set_cookies("esjzone", self.cookies)

novel_downloader/core/fetchers/linovelib/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.linovelib
+----------------------------------------
+
+"""
+
+from .browser import LinovelibBrowser
+from .session import LinovelibSession
+
+__all__ = [
+    "LinovelibBrowser",
+    "LinovelibSession",
+]

novel_downloader/core/fetchers/linovelib/browser.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.linovelib.browser
+------------------------------------------------
+
+"""
+
+import re
+from typing import Any
+
+from novel_downloader.core.fetchers.base import BaseBrowser
+from novel_downloader.models import FetcherConfig
+from novel_downloader.utils.time_utils import async_sleep_with_random_delay
+
+
+class LinovelibBrowser(BaseBrowser):
+    """
+    A browser class for interacting with Linovelib (www.linovelib.com) novel website.
+    """
+
+    BASE_URL = "https://www.linovelib.com"
+    BOOK_INFO_URL = "https://www.linovelib.com/novel/{book_id}.html"
+    BOOK_VOL_URL = "https://www.linovelib.com/novel/{book_id}/{vol_id}.html"
+    CHAPTER_URL = "https://www.linovelib.com/novel/{book_id}/{chapter_id}.html"
+
+    _VOL_ID_PATTERN: re.Pattern[str] = re.compile(r"/novel/\d+/(vol_\d+)\.html")
+
+    def __init__(
+        self,
+        config: FetcherConfig,
+        reuse_page: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("linovelib", config, reuse_page, **kwargs)
+
+    async def get_book_info(
+        self,
+        book_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of the book info page.
+
+        :param book_id: The book identifier.
+        :return: A list of HTML strings: [info_html, vol1_html, ..., volN_html]
+        """
+        url = self.book_info_url(book_id=book_id)
+        info_html = await self.fetch(url, **kwargs)
+
+        vol_ids = self._extract_vol_ids(info_html)
+        vol_ids.reverse()
+
+        vol_htmls = []
+        for vol_id in vol_ids:
+            await async_sleep_with_random_delay(
+                self.request_interval,
+                mul_spread=1.1,
+                max_sleep=self.request_interval + 2,
+            )
+            html = await self.get_book_volume(book_id, vol_id, **kwargs)
+            if html:
+                vol_htmls.append(html)
+
+        return [info_html] + vol_htmls
+
+    async def get_book_volume(
+        self,
+        book_id: str,
+        vol_id: str,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Fetch the HTML content of a specific volume.
+
+        :param book_id: The book identifier.
+        :param vol_id: The volume identifier.
+        :return: The volume content as a string.
+        """
+        url = self.volume_url(book_id=book_id, vol_id=vol_id)
+        return await self.fetch(url, **kwargs)
+
+    async def get_book_chapter(
+        self,
+        book_id: str,
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of a single chapter asynchronously.
+
+        :param book_id: The book identifier.
+        :param chapter_id: The chapter identifier.
+        :return: The chapter content as a string.
+        """
+        html_pages: list[str] = []
+        idx = 1
+
+        while True:
+            chapter_suffix = chapter_id if idx == 1 else f"{chapter_id}_{idx}"
+            relative_path = self.relative_chapter_url(book_id, chapter_suffix)
+            full_url = self.BASE_URL + relative_path
+
+            if idx > 1 and relative_path not in html_pages[-1]:
+                break
+
+            try:
+                html = await self.fetch(full_url, **kwargs)
+            except Exception as exc:
+                self.logger.warning(
+                    "[async] get_book_chapter(%s page %d) failed: %s",
+                    chapter_id,
+                    idx,
+                    exc,
+                )
+                break
+
+            html_pages.append(html)
+            idx += 1
+            await async_sleep_with_random_delay(
+                self.request_interval,
+                mul_spread=1.1,
+                max_sleep=self.request_interval + 2,
+            )
+
+        return html_pages
+
+    @classmethod
+    def book_info_url(cls, book_id: str) -> str:
+        """
+        Construct the URL for fetching a book's info page.
+
+        :param book_id: The identifier of the book.
+        :return: Fully qualified URL for the book info page.
+        """
+        return cls.BOOK_INFO_URL.format(book_id=book_id)
+
+    @classmethod
+    def volume_url(cls, book_id: str, vol_id: str) -> str:
+        """
+        Construct the URL for fetching a specific volume.
+
+        :param book_id: The identifier of the book.
+        :param vol_id: The identifier of the volume.
+        :return: Fully qualified volume URL.
+        """
+        return cls.BOOK_VOL_URL.format(book_id=book_id, vol_id=vol_id)
+
+    @classmethod
+    def chapter_url(cls, book_id: str, chapter_id: str) -> str:
+        """
+        Construct the URL for fetching a specific chapter.
+
+        :param book_id: The identifier of the book.
+        :param chapter_id: The identifier of the chapter.
+        :return: Fully qualified chapter URL.
+        """
+        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
+
+    @property
+    def hostname(self) -> str:
+        return "www.linovelib.com"
+
+    @classmethod
+    def relative_chapter_url(cls, book_id: str, chapter_id: str) -> str:
+        """
+        Return the relative URL path for a given chapter.
+        """
+        return f"/novel/{book_id}/{chapter_id}.html"
+
+    def _extract_vol_ids(self, html_str: str) -> list[str]:
+        """
+        Extract volume IDs (like 'vol_12345') from the info HTML.
+
+        :param html_str: Raw HTML of the info page.
+        :return: List of volume ID strings.
+        """
+        # /novel/{book_id}/{vol_id}.html
+        return self._VOL_ID_PATTERN.findall(html_str)