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

novel_downloader/core/downloaders/yamibo/yamibo_sync.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.downloaders.yamibo.yamibo_sync
-----------------------------------------------------
-
-"""
-
-from novel_downloader.config.models import DownloaderConfig
-from novel_downloader.core.downloaders.common import CommonDownloader
-from novel_downloader.core.interfaces import (
-    ParserProtocol,
-    SaverProtocol,
-    SyncRequesterProtocol,
-)
-
-
-class YamiboDownloader(CommonDownloader):
-    """"""
-
-    def __init__(
-        self,
-        requester: SyncRequesterProtocol,
-        parser: ParserProtocol,
-        saver: SaverProtocol,
-        config: DownloaderConfig,
-    ):
-        super().__init__(requester, parser, saver, config, "yamibo")

novel_downloader/core/factory/requester.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.factory.requester_factory
------------------------------------------------
-
-This module implements a factory function for retrieving requester instances
-based on the target novel platform (site).
-"""
-
-from collections.abc import Callable
-
-from novel_downloader.config import RequesterConfig, load_site_rules
-from novel_downloader.core.interfaces import (
-    AsyncRequesterProtocol,
-    SyncRequesterProtocol,
-)
-from novel_downloader.core.requesters import (
-    BiqugeAsyncSession,
-    BiqugeSession,
-    CommonAsyncSession,
-    CommonSession,
-    EsjzoneAsyncSession,
-    EsjzoneSession,
-    QianbiAsyncSession,
-    QianbiSession,
-    QidianBrowser,
-    QidianSession,
-    SfacgAsyncSession,
-    SfacgSession,
-    YamiboAsyncSession,
-    YamiboSession,
-)
-
-AsyncRequesterBuilder = Callable[[RequesterConfig], AsyncRequesterProtocol]
-SyncRequesterBuilder = Callable[[RequesterConfig], SyncRequesterProtocol]
-
-
-_async_site_map: dict[str, AsyncRequesterBuilder] = {
-    "biquge": BiqugeAsyncSession,
-    "esjzone": EsjzoneAsyncSession,
-    "qianbi": QianbiAsyncSession,
-    "sfacg": SfacgAsyncSession,
-    "yamibo": YamiboAsyncSession,
-}
-_sync_site_map: dict[
-    str,
-    dict[str, SyncRequesterBuilder],
-] = {
-    "biquge": {
-        "session": BiqugeSession,
-    },
-    "esjzone": {
-        "session": EsjzoneSession,
-    },
-    "qianbi": {
-        "session": QianbiSession,
-    },
-    "qidian": {
-        "session": QidianSession,
-        "browser": QidianBrowser,
-    },
-    "sfacg": {
-        "session": SfacgSession,
-    },
-    "yamibo": {
-        "session": YamiboSession,
-    },
-}
-
-
-def get_async_requester(
-    site: str,
-    config: RequesterConfig,
-) -> AsyncRequesterProtocol:
-    """
-    Returns an AsyncRequesterProtocol for the given site.
-
-    :param site: Site name (e.g., 'qidian')
-    :param config: Configuration for the requester
-    :return: An instance of a requester class
-    """
-    site_key = site.lower()
-
-    # site-specific
-    if site_key in _async_site_map:
-        return _async_site_map[site_key](config)
-
-    # fallback
-    site_rules = load_site_rules()
-    site_rule = site_rules.get(site_key)
-    if site_rule is None:
-        raise ValueError(f"Unsupported site: {site}")
-    profile = site_rule["profile"]
-    return CommonAsyncSession(config, site_key, profile)
-
-
-def get_sync_requester(
-    site: str,
-    config: RequesterConfig,
-) -> SyncRequesterProtocol:
-    """
-    Returns a RequesterProtocol for the given site.
-
-    :param site: Site name (e.g., 'qidian')
-    :param config: Configuration for the requester
-    :return: An instance of a requester class
-    """
-    site_key = site.lower()
-    site_entry = _sync_site_map.get(site_key)
-
-    # site-specific
-    if site_entry:
-        cls = site_entry.get(config.mode)
-        if cls:
-            return cls(config)
-
-    # fallback
-    site_rules = load_site_rules()
-    site_rule = site_rules.get(site_key)
-    if site_rule is None:
-        raise ValueError(f"Unsupported site: {site}")
-    profile = site_rule["profile"]
-    return CommonSession(config, site_key, profile)
-
-
-def get_requester(
-    site: str,
-    config: RequesterConfig,
-) -> AsyncRequesterProtocol | SyncRequesterProtocol:
-    """
-    Dispatches to either get_async_requester or get_sync_requester
-    based on config.mode. Treats 'browser' and 'async' as async modes,
-    'session' as sync; anything else is an error.
-
-    :param site: Site name (e.g., 'qidian')
-    :param config: Configuration for the requester
-    :return: An instance of a requester class
-    """
-    mode = config.mode.lower()
-    if mode == "async":
-        return get_async_requester(site, config)
-    if mode in ("browser", "session"):
-        return get_sync_requester(site, config)
-    raise ValueError(f"Unknown mode '{config.mode}' for site '{site}'")

novel_downloader/core/factory/saver.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.factory.parser_factory
---------------------------------------------
-
-This module implements a factory function for creating saver instances
-based on the site name and parser mode specified in the configuration.
-"""
-
-from collections.abc import Callable
-
-from novel_downloader.config import SaverConfig, load_site_rules
-from novel_downloader.core.interfaces import SaverProtocol
-from novel_downloader.core.savers import (
-    BiqugeSaver,
-    CommonSaver,
-    EsjzoneSaver,
-    QianbiSaver,
-    QidianSaver,
-    SfacgSaver,
-    YamiboSaver,
-)
-
-SaverBuilder = Callable[[SaverConfig], SaverProtocol]
-
-_site_map: dict[str, SaverBuilder] = {
-    "biquge": BiqugeSaver,
-    "esjzone": EsjzoneSaver,
-    "qianbi": QianbiSaver,
-    "qidian": QidianSaver,
-    "sfacg": SfacgSaver,
-    "yamibo": YamiboSaver,
-}
-
-
-def get_saver(site: str, config: SaverConfig) -> SaverProtocol:
-    """
-    Returns a site-specific saver instance.
-
-    :param site: Site name (e.g., 'qidian')
-    :param config: Configuration for the saver
-    :return: An instance of a saver class
-    """
-    site_key = site.lower()
-
-    # site-specific
-    saver_class = _site_map.get(site_key)
-    if saver_class:
-        return saver_class(config)
-
-    # Fallback
-    site_rules = load_site_rules()
-    if site_key not in site_rules:
-        raise ValueError(f"Unsupported site: {site}")
-
-    return CommonSaver(config, site_key)

novel_downloader/core/interfaces/async_downloader.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.interfaces.async_downloader
-----------------------------------------------------------
-
-This module defines the AsyncDownloaderProtocol, a structural interface
-that outlines the expected behavior of any downloader class.
-"""
-
-from typing import Protocol
-
-
-class AsyncDownloaderProtocol(Protocol):
-    """
-    Protocol for fully-asynchronous downloader classes.
-
-    Defines the expected interface for any downloader implementation,
-    including both batch and single book downloads,
-    as well as optional pre-download hooks.
-    """
-
-    async def download(self, book_ids: list[str]) -> None:
-        """
-        Batch download entry point.
-
-        :param book_ids: List of book IDs to download.
-        """
-        ...
-
-    async def download_one(self, book_id: str) -> None:
-        """
-        Download logic for a single book.
-
-        :param book_id: The identifier of the book.
-        """
-        ...

novel_downloader/core/interfaces/async_requester.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.interfaces.async_requester
---------------------------------------------------------
-
-Defines the AsyncRequesterProtocol interface for fetching raw HTML or JSON
-for book info pages, individual chapters, managing request lifecycle,
-and optionally retrieving a user's authenticated bookcase.
-"""
-
-from typing import Any, Literal, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class AsyncRequesterProtocol(Protocol):
-    """
-    An async requester must be able to fetch raw HTML/data for:
-      - a book's info page,
-      - a specific chapter page,
-    and manage login/shutdown asynchronously.
-    """
-
-    def is_async(self) -> Literal[True]:
-        ...
-
-    async def login(
-        self,
-        username: str = "",
-        password: str = "",
-        manual_login: bool = False,
-        **kwargs: Any,
-    ) -> bool:
-        """
-        Attempt to log in asynchronously.
-        :returns: True if login succeeded.
-        """
-        ...
-
-    async def get_book_info(
-        self,
-        book_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the raw HTML (or JSON) of the book info page asynchronously.
-
-        :param book_id: The book identifier.
-        :return: The page content as a string.
-        """
-        ...
-
-    async def get_book_chapter(
-        self,
-        book_id: str,
-        chapter_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the raw HTML (or JSON) of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
-        """
-        ...
-
-    async def get_bookcase(
-        self,
-        page: int = 1,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Optional: Retrieve the HTML content of the authenticated
-        user's bookcase page asynchronously.
-
-        :return: The HTML markup of the bookcase page.
-        """
-        ...
-
-    async def close(self) -> None:
-        """
-        Shutdown and clean up any resources (e.g., close aiohttp session).
-        """
-        ...

novel_downloader/core/interfaces/sync_downloader.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.interfaces.sync_downloader
-------------------------------------------------
-
-This module defines the SyncDownloaderProtocol, a structural interface
-that outlines the expected behavior of any downloader class.
-"""
-
-from typing import Protocol
-
-
-class SyncDownloaderProtocol(Protocol):
-    """
-    Protocol for downloader classes.
-
-    Defines the expected interface for any downloader implementation,
-    including both batch and single book downloads,
-    as well as optional pre-download hooks.
-    """
-
-    def download(self, book_ids: list[str]) -> None:
-        """
-        Batch download entry point.
-
-        :param book_ids: List of book IDs to download.
-        """
-        ...
-
-    def download_one(self, book_id: str) -> None:
-        """
-        Download logic for a single book.
-
-        :param book_id: The identifier of the book.
-        """
-        ...

novel_downloader/core/interfaces/sync_requester.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.interfaces.sync_requester
------------------------------------------------
-
-Defines the RequesterProtocol interface for fetching raw HTML or JSON
-for book info pages, individual chapters, managing request lifecycle,
-and optionally retrieving a user's authenticated bookcase.
-"""
-
-from typing import Any, Literal, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class SyncRequesterProtocol(Protocol):
-    """
-    A requester must be able to fetch raw HTML/data for:
-      - a book's info page,
-      - a specific chapter page.
-    """
-
-    def is_async(self) -> Literal[False]:
-        ...
-
-    def login(
-        self,
-        username: str = "",
-        password: str = "",
-        manual_login: bool = False,
-        **kwargs: Any,
-    ) -> bool:
-        """
-        Attempt to log in
-        """
-        ...
-
-    def get_book_info(
-        self,
-        book_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the raw HTML (or JSON) of the book info page.
-
-        :param book_id: The book identifier.
-        :return: The page content as a string.
-        """
-        ...
-
-    def get_book_chapter(
-        self,
-        book_id: str,
-        chapter_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the raw HTML (or JSON) of a single chapter.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
-        """
-        ...
-
-    def get_bookcase(
-        self,
-        page: int = 1,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Optional: Retrieve the HTML content of the authenticated user's bookcase page.
-
-        :param page: Page idx
-        :return: The HTML markup of the bookcase page.
-        """
-        ...
-
-    def close(self) -> None:
-        """
-        Shutdown and cleans up resources.
-        """
-        ...

novel_downloader/core/parsers/qidian/browser/__init__.py

@@ -1,12 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.browser
---------------------------------------------
-
-This package provides parsing components for handling Qidian
-pages that have been rendered by a browser engine.
-"""
-
-from .main_parser import QidianBrowserParser
-
-__all__ = ["QidianBrowserParser"]

novel_downloader/core/parsers/qidian/browser/chapter_normal.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.browser.chapter_normal
------------------------------------------------------------
-
-Parser logic for extracting readable text from Qidian chapters
-that use plain (non-encrypted) browser-rendered HTML.
-"""
-
-import logging
-
-from bs4 import BeautifulSoup
-
-from novel_downloader.utils.chapter_storage import ChapterDict
-
-from ..shared import (
-    extract_chapter_info,
-    find_ssr_page_context,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def parse_normal_chapter(
-    soup: BeautifulSoup,
-    chapter_id: str,
-) -> ChapterDict | None:
-    """
-    Extract and format the chapter text from a normal Qidian page.
-    Returns empty string if VIP/encrypted.
-
-    This method performs the following steps:
-      1. Parses HTML into soup.
-      2. Skips parsing if VIP or encrypted.
-      3. Locates main content container.
-      4. Extracts SSR-rendered chapter info (title, author note).
-      5. Removes review spans.
-      6. Extracts paragraph texts and formats them.
-
-    :param html_str: Raw HTML content of the chapter page.
-    :return: Formatted chapter text or empty string if not parsable.
-    """
-    try:
-        main = soup.select_one("div#app div#reader-content main")
-        if not main:
-            logger.warning("[Parser] Main content not found for chapter")
-            return None
-
-        ssr_data = find_ssr_page_context(soup)
-        chapter_info = extract_chapter_info(ssr_data)
-        if not chapter_info:
-            logger.warning(
-                "[Parser] ssr_chapterInfo not found for chapter '%s'", chapter_id
-            )
-            return None
-
-        title = chapter_info.get("chapterName", "Untitled")
-        chapter_id = chapter_info.get("chapterId", "")
-        author_say = chapter_info.get("authorSay", "")
-        update_time = chapter_info.get("updateTime", "")
-        update_timestamp = chapter_info.get("updateTimestamp", 0)
-        modify_time = chapter_info.get("modifyTime", 0)
-        word_count = chapter_info.get("wordsCount", 0)
-        seq = chapter_info.get("seq", None)
-        volume = chapter_info.get("extra", {}).get("volumeName", "")
-
-        # remove review spans
-        for span in main.select("span.review"):
-            span.decompose()
-
-        paras = [p.get_text(strip=True) for p in main.find_all("p")]
-        chapter_text = "\n\n".join(paras)
-
-        return {
-            "id": str(chapter_id),
-            "title": title,
-            "content": chapter_text,
-            "extra": {
-                "author_say": author_say.strip() if author_say else "",
-                "updated_at": update_time,
-                "update_timestamp": update_timestamp,
-                "modify_time": modify_time,
-                "word_count": word_count,
-                "seq": seq,
-                "volume": volume,
-            },
-        }
-
-    except Exception as e:
-        logger.warning(
-            "[Parser] parse error for normal chapter '%s': %s", chapter_id, e
-        )
-    return None

novel_downloader/core/parsers/qidian/browser/chapter_router.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.browser.chapter_router
------------------------------------------------------------
-
-Routing logic for selecting the correct chapter parser for Qidian browser pages.
-
-This module acts as a dispatcher that analyzes a chapter's HTML content and
-routes the parsing task to either the encrypted or normal chapter parser.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from novel_downloader.utils.chapter_storage import ChapterDict
-
-from ..shared import (
-    can_view_chapter,
-    html_to_soup,
-    is_encrypted,
-)
-from .chapter_normal import parse_normal_chapter
-
-if TYPE_CHECKING:
-    from .main_parser import QidianBrowserParser
-
-logger = logging.getLogger(__name__)
-
-
-def parse_chapter(
-    parser: QidianBrowserParser,
-    html_str: str,
-    chapter_id: str,
-) -> ChapterDict | None:
-    """
-    Extract and return the formatted textual content of chapter.
-
-    :param parser: Instance of QidianBrowserParser.
-    :param html_str: Raw HTML content of the chapter page.
-    :param chapter_id: Identifier of the chapter being parsed.
-    :return: Formatted chapter text or empty string if not parsable.
-    """
-    try:
-        soup = html_to_soup(html_str)
-
-        if not can_view_chapter(soup):
-            logger.warning(
-                "[Parser] Chapter '%s' is not purchased or inaccessible.", chapter_id
-            )
-            return None
-
-        if is_encrypted(soup):
-            if not parser._decode_font:
-                return None
-            try:
-                from .chapter_encrypted import parse_encrypted_chapter
-
-                return parse_encrypted_chapter(parser, soup, chapter_id)
-            except ImportError:
-                logger.warning(
-                    "[Parser] Encrypted chapter '%s' requires extra dependencies.",
-                    chapter_id,
-                )
-                return None
-
-        return parse_normal_chapter(soup, chapter_id)
-    except Exception as e:
-        logger.warning("[Parser] parse error for chapter '%s': %s", chapter_id, e)
-    return None

novel_downloader/core/parsers/qidian/session/__init__.py

@@ -1,12 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.session
---------------------------------------------
-
-This package provides parsing components for handling Qidian
-pages that have been rendered by a session.
-"""
-
-from .main_parser import QidianSessionParser
-
-__all__ = ["QidianSessionParser"]