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

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

@@ -1,26 +1,22 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters.sfacg.async_session
-----------------------------------------------------
+novel_downloader.core.fetchers.sfacg.session
+--------------------------------------------
 
 """
 
-import asyncio
-from http.cookies import SimpleCookie
 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
 
 
-class SfacgAsyncSession(BaseAsyncSession):
+class SfacgSession(BaseSession):
     """
-    A async session class for interacting with the
-    Sfacg (m.sfacg.com) novel website.
+    A session class for interacting with the Sfacg (m.sfacg.com) novel website.
     """
 
+    LOGIN_URL = "https://m.sfacg.com/login"
     BOOKCASE_URL = "https://m.sfacg.com/sheets/"
     BOOK_INFO_URL = "https://m.sfacg.com/b/{book_id}/"
     BOOK_CATALOG_URL = "https://m.sfacg.com/i/{book_id}/"
@@ -28,49 +24,33 @@ class SfacgAsyncSession(BaseAsyncSession):
 
     def __init__(
         self,
-        config: RequesterConfig,
-    ):
-        super().__init__(config)
-        self._logged_in: bool = False
-        self._retry_times = config.retry_times
+        config: FetcherConfig,
+        cookies: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("sfacg", 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("sfacg")
-
-        self.update_cookies(cookies)
-        for attempt in range(1, self._retry_times + 1):
-            if await self._check_login_status():
-                self.logger.debug("[auth] Already logged in.")
-                self._logged_in = True
-                return True
-
-            if attempt == 1:
-                print(t("session_login_prompt_intro"))
-            cookie_str = input(
-                t(
-                    "session_login_prompt_paste_cookie",
-                    attempt=attempt,
-                    max_retries=self._retry_times,
-                )
-            ).strip()
-
-            cookies = self._parse_cookie_input(cookie_str)
-            if not cookies:
-                print(t("session_login_prompt_invalid_cookie"))
-                continue
-
+        if cookies:
             self.update_cookies(cookies)
-        self._logged_in = await self._check_login_status()
-        return self._logged_in
+
+        if await self._check_login_status():
+            self._is_logged_in = True
+            self.logger.debug("[auth] Logged in via cookies.")
+            return True
+
+        self._is_logged_in = False
+        return False
 
     async def get_book_info(
         self,
@@ -80,18 +60,15 @@ class SfacgAsyncSession(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.
         """
         info_url = self.book_info_url(book_id=book_id)
         catalog_url = self.book_catalog_url(book_id=book_id)
 
-        info_html, catalog_html = await asyncio.gather(
-            self.fetch(info_url, **kwargs),
-            self.fetch(catalog_url, **kwargs),
-        )
+        info_html = await self.fetch(info_url, **kwargs)
+        catalog_html = await self.fetch(catalog_url, **kwargs)
+
         return [info_html, catalog_html]
 
     async def get_book_chapter(
@@ -112,7 +89,6 @@ class SfacgAsyncSession(BaseAsyncSession):
 
     async def get_bookcase(
         self,
-        page: int = 1,
         **kwargs: Any,
     ) -> list[str]:
         """
@@ -123,6 +99,19 @@ class SfacgAsyncSession(BaseAsyncSession):
         url = self.bookcase_url()
         return [await self.fetch(url, **kwargs)]
 
+    @property
+    def login_fields(self) -> list[LoginField]:
+        return [
+            LoginField(
+                name="cookies",
+                label="Cookie",
+                type="cookie",
+                required=True,
+                placeholder="请输入你的登录 Cookie",
+                description="可以通过浏览器开发者工具复制已登录状态下的 Cookie",
+            ),
+        ]
+
     @classmethod
     def bookcase_url(cls) -> str:
         """
@@ -163,6 +152,10 @@ class SfacgAsyncSession(BaseAsyncSession):
         """
         return cls.CHAPTER_URL.format(chapter_id=chapter_id)
 
+    @property
+    def hostname(self) -> str:
+        return "m.sfacg.com"
+
     async def _check_login_status(self) -> bool:
         """
         Check whether the user is currently logged in by
@@ -179,26 +172,3 @@ class SfacgAsyncSession(BaseAsyncSession):
         if not resp_text:
             return False
         return not any(kw in resp_text[0] for kw in keywords)
-
-    @staticmethod
-    def _parse_cookie_input(cookie_str: str) -> dict[str, str]:
-        """
-        Parse a raw cookie string (e.g. from browser dev tools) into a dict.
-        Returns an empty dict if parsing fails.
-
-        :param cookie_str: The raw cookie header string.
-        :return: Parsed cookie dict.
-        """
-        filtered = "; ".join(pair for pair in cookie_str.split(";") if "=" in pair)
-        parsed = SimpleCookie()
-        try:
-            parsed.load(filtered)
-            return {k: v.value for k, v in parsed.items()}
-        except Exception:
-            return {}
-
-    async def _on_close(self) -> None:
-        """
-        Save cookies to the state manager before closing.
-        """
-        state_mgr.set_cookies("sfacg", self.cookies)

novel_downloader/core/fetchers/yamibo/__init__.py

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

novel_downloader/core/fetchers/yamibo/browser.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.yamibo.browser
+---------------------------------------------
+
+"""
+
+from typing import Any
+
+from novel_downloader.core.fetchers.base import BaseBrowser
+from novel_downloader.models import FetcherConfig, LoginField
+
+
+class YamiboBrowser(BaseBrowser):
+    """
+    A browser class for interacting with the Yamibo (www.yamibo.com) novel website.
+    """
+
+    BASE_URL = "https://www.yamibo.com"
+    BOOKCASE_URL = "https://www.yamibo.com/my/fav"
+    BOOK_INFO_URL = "https://www.yamibo.com/novel/{book_id}"
+    CHAPTER_URL = "https://www.yamibo.com/novel/view-chapter?id={chapter_id}"
+
+    LOGIN_URL = "https://www.yamibo.com/user/login"
+
+    def __init__(
+        self,
+        config: FetcherConfig,
+        reuse_page: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("yamibo", 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
+
+        for i in range(1, attempt + 1):
+            try:
+                login_page = await self.context.new_page()
+                await login_page.goto(self.LOGIN_URL, wait_until="networkidle")
+
+                await login_page.fill("#loginform-username", username)
+                await login_page.fill("#loginform-password", password)
+
+                before_url = login_page.url
+                await login_page.click('button[name="login-button"]')
+
+                try:
+                    await login_page.wait_for_url(
+                        lambda url, before_url=before_url: url_changed(url, before_url),
+                        timeout=15000,
+                    )
+                except Exception as e:
+                    self.logger.debug(
+                        f"[auth] No URL change after login attempt {i}: {e}"
+                    )
+
+                await login_page.close()
+
+                self._is_logged_in = await self._check_login_status()
+                if self._is_logged_in:
+                    self.logger.info(f"[auth] Login successful on attempt {i}.")
+                    return True
+                else:
+                    self.logger.warning(
+                        f"[auth] Login check failed after attempt {i}. Retrying..."
+                    )
+
+            except Exception as e:
+                self.logger.error(
+                    f"[auth] Unexpected error during login attempt {i}: {e}"
+                )
+
+        self.logger.error(f"[auth] Login failed after {attempt} attempt(s).")
+        return False
+
+    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.LOGIN_URL)
+            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="用于登录 www.yamibo.com 的用户名",
+            ),
+            LoginField(
+                name="password",
+                label="密码",
+                type="password",
+                required=True,
+                placeholder="请输入你的密码",
+                description="用于登录 www.yamibo.com 的密码",
+            ),
+        ]
+
+    @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)
+
+    @property
+    def hostname(self) -> str:
+        return "www.yamibo.com"
+
+    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 = [
+            "登录 - 百合会",
+            "用户名/邮箱",
+        ]
+        resp_text = await self.get_bookcase()
+        if not resp_text:
+            return False
+        return not any(kw in resp_text[0] for kw in keywords)
+
+
+def url_changed(url: str, before: str) -> bool:
+    return url != before

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

@@ -1,25 +1,22 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters.yamibo.async_session
------------------------------------------------------
+novel_downloader.core.fetchers.yamibo.session
+---------------------------------------------
 
 """
 
 from typing import Any
 
-from lxml import etree
+from lxml import html
 
-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 YamiboAsyncSession(BaseAsyncSession):
+class YamiboSession(BaseSession):
     """
-    A async session class for interacting with the
-    yamibo (www.yamibo.com) novel website.
+    A session class for interacting with the Yamibo (www.yamibo.com) novel website.
     """
 
     BASE_URL = "https://www.yamibo.com"
@@ -31,45 +28,50 @@ class YamiboAsyncSession(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__("yamibo", 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("yamibo")
-        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,
@@ -79,8 +81,6 @@ class YamiboAsyncSession(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.
         """
@@ -105,7 +105,6 @@ class YamiboAsyncSession(BaseAsyncSession):
 
     async def get_bookcase(
         self,
-        page: int = 1,
         **kwargs: Any,
     ) -> list[str]:
         """
@@ -116,6 +115,27 @@ class YamiboAsyncSession(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="用于登录 www.yamibo.com 的用户名",
+            ),
+            LoginField(
+                name="password",
+                label="密码",
+                type="password",
+                required=True,
+                placeholder="请输入你的密码",
+                description="用于登录 www.yamibo.com 的密码",
+            ),
+        ]
+
     @classmethod
     def bookcase_url(cls) -> str:
         """
@@ -144,7 +164,11 @@ class YamiboAsyncSession(BaseAsyncSession):
         :param chapter_id: The identifier of the chapter.
         :return: Fully qualified chapter URL.
         """
-        return cls.CHAPTER_URL.format(chapter_id=chapter_id)
+        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
+
+    @property
+    def hostname(self) -> str:
+        return "www.yamibo.com"
 
     async def _api_login(self, username: str, password: str) -> bool:
         """
@@ -158,7 +182,7 @@ class YamiboAsyncSession(BaseAsyncSession):
             resp_1 = await self.get(self.LOGIN_URL)
             resp_1.raise_for_status()
             text_1 = await resp_1.text()
-            tree = etree.HTML(text_1)
+            tree = html.fromstring(text_1)
             csrf_value = tree.xpath('//input[@name="_csrf-frontend"]/@value')
             csrf_value = csrf_value[0] if csrf_value else ""
             if not csrf_value:
@@ -203,9 +227,3 @@ class YamiboAsyncSession(BaseAsyncSession):
         if not resp_text:
             return False
         return not any(kw in resp_text[0] for kw in keywords)
-
-    async def _on_close(self) -> None:
-        """
-        Save cookies to the state manager before closing.
-        """
-        state_mgr.set_cookies("yamibo", self.cookies)

novel_downloader/core/interfaces/__init__.py

@@ -9,23 +9,19 @@ injection.
 
 Included protocols:
 - DownloaderProtocol
+- FetcherProtocol
 - ParserProtocol
-- RequesterProtocol
-- SaverProtocol
+- ExporterProtocol
 """
 
-from .async_downloader import AsyncDownloaderProtocol
-from .async_requester import AsyncRequesterProtocol
+from .downloader import DownloaderProtocol
+from .exporter import ExporterProtocol
+from .fetcher import FetcherProtocol
 from .parser import ParserProtocol
-from .saver import SaverProtocol
-from .sync_downloader import SyncDownloaderProtocol
-from .sync_requester import SyncRequesterProtocol
 
 __all__ = [
-    "AsyncDownloaderProtocol",
-    "AsyncRequesterProtocol",
+    "DownloaderProtocol",
+    "ExporterProtocol",
+    "FetcherProtocol",
     "ParserProtocol",
-    "SaverProtocol",
-    "SyncDownloaderProtocol",
-    "SyncRequesterProtocol",
 ]