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

novel_downloader/core/requesters/yamibo/session.py

@@ -0,0 +1,237 @@
+"""
+novel_downloader.core.requesters.yamibo.session
+-----------------------------------------------
+
+"""
+
+from typing import Any
+
+from lxml import etree
+
+from novel_downloader.config.models import RequesterConfig
+from novel_downloader.core.requesters.base import BaseSession
+from novel_downloader.utils.i18n import t
+from novel_downloader.utils.state import state_mgr
+from novel_downloader.utils.time_utils import sleep_with_random_delay
+
+
+class YamiboSession(BaseSession):
+    """
+    A session 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: 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
+
+    def login(
+        self,
+        username: str = "",
+        password: str = "",
+        manual_login: bool = False,
+        **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
+
+        self.update_cookies(cookies)
+        for _ in range(self._retry_times):
+            if self._check_login_status():
+                self.logger.debug("[auth] Already logged in.")
+                self._logged_in = True
+                return True
+            if username and password and not self._api_login(username, password):
+                print(t("session_login_failed", site="esjzone"))
+            sleep_with_random_delay(
+                self._request_interval,
+                mul_spread=1.1,
+                max_sleep=self._request_interval + 2,
+            )
+
+        self._logged_in = self._check_login_status()
+        return self._logged_in
+
+    def get_book_info(
+        self,
+        book_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of the book info and catalog pages.
+
+        Order: [info, catalog]
+
+        :param book_id: The book identifier.
+        :return: The page content as a string.
+        """
+        url = self.book_info_url(book_id=book_id)
+        try:
+            resp = self.get(url, **kwargs)
+            resp.raise_for_status()
+            return [resp.text]
+        except Exception as exc:
+            self.logger.warning(
+                "[session] get_book_info(%s) failed: %s",
+                book_id,
+                exc,
+            )
+        return []
+
+    def get_book_chapter(
+        self,
+        book_id: str,
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the HTML of a single chapter.
+
+        :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)
+        try:
+            resp = self.get(url, **kwargs)
+            resp.raise_for_status()
+            return [resp.text]
+        except Exception as exc:
+            self.logger.warning(
+                "[session] get_book_chapter(%s) failed: %s",
+                book_id,
+                exc,
+            )
+        return []
+
+    def get_bookcase(
+        self,
+        page: int = 1,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Retrieve the user's *bookcase* page.
+
+        :return: The HTML markup of the bookcase page.
+        """
+        url = self.bookcase_url()
+        try:
+            resp = self.get(url, **kwargs)
+            resp.raise_for_status()
+            return [resp.text]
+        except Exception as exc:
+            self.logger.warning(
+                "[session] get_bookcase failed: %s",
+                exc,
+            )
+        return []
+
+    @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(chapter_id=chapter_id)
+
+    def _api_login(self, username: str, password: str) -> bool:
+        """
+        Login to the API using a 2-step token-based process.
+
+        Step 1: Get token `_csrf-frontend`.
+        Step 2: Use token and credentials to perform login.
+        Return True if login succeeds, False otherwise.
+        """
+        try:
+            resp_1 = self.get(self.LOGIN_URL)
+            resp_1.raise_for_status()
+            tree = etree.HTML(resp_1.text)
+            csrf_value = tree.xpath('//input[@name="_csrf-frontend"]/@value')
+            csrf_value = csrf_value[0] if csrf_value else ""
+            if not csrf_value:
+                self.logger.warning("[session] _api_login: CSRF token not found.")
+                return False
+        except Exception as exc:
+            self.logger.warning("[session] _api_login failed at step 1: %s", exc)
+            return False
+
+        data_2 = {
+            "_csrf-frontend": csrf_value,
+            "LoginForm[username]": username,
+            "LoginForm[password]": password,
+            # "LoginForm[rememberMe]": 0,
+            "LoginForm[rememberMe]": 1,
+            "login-button": "",
+        }
+        temp_headers = dict(self.headers)
+        temp_headers["Origin"] = self.BASE_URL
+        temp_headers["Referer"] = self.LOGIN_URL
+        try:
+            resp_2 = self.post(self.LOGIN_URL, data=data_2, headers=temp_headers)
+            resp_2.raise_for_status()
+            return "登录成功" in resp_2.text
+        except Exception as exc:
+            self.logger.warning("[session] _api_login failed at step 2: %s", exc)
+        return False
+
+    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 = self.get_bookcase()
+        if not resp_text:
+            return False
+        return not any(kw in resp_text[0] for kw in keywords)
+
+    def _on_close(self) -> None:
+        """
+        Save cookies to the state manager before closing.
+        """
+        state_mgr.set_cookies("yamibo", self.cookies)

novel_downloader/core/savers/__init__.py

@@ -6,17 +6,29 @@ novel_downloader.core.savers
 This module defines saver classes for different novel platforms.
 
 Currently supported platforms:
-- Biquge (笔趣阁)
-- Qidian (起点中文网)
-- CommonSaver (通用)
+- biquge (笔趣阁)
+- esjzone (ESJ Zone)
+- qianbi (铅笔小说)
+- qidian (起点中文网)
+- sfacg (SF轻小说)
+- yamibo (百合会)
+- common (通用架构)
 """
 
 from .biquge import BiqugeSaver
 from .common import CommonSaver
+from .esjzone import EsjzoneSaver
+from .qianbi import QianbiSaver
 from .qidian import QidianSaver
+from .sfacg import SfacgSaver
+from .yamibo import YamiboSaver
 
 __all__ = [
     "BiqugeSaver",
     "CommonSaver",
+    "EsjzoneSaver",
+    "QianbiSaver",
     "QidianSaver",
+    "SfacgSaver",
+    "YamiboSaver",
 ]

novel_downloader/core/savers/base.py

@@ -39,9 +39,10 @@ class BaseSaver(SaverProtocol, abc.ABC):
         """
         self._config = config
 
-        self._raw_data_dir = Path(config.raw_data_dir)
+        self._base_cache_dir = Path(config.cache_dir)
+        self._base_raw_data_dir = Path(config.raw_data_dir)
         self._output_dir = Path(config.output_dir)
-        self._raw_data_dir.mkdir(parents=True, exist_ok=True)
+        self._base_cache_dir.mkdir(parents=True, exist_ok=True)
         self._output_dir.mkdir(parents=True, exist_ok=True)
 
         self._filename_template = config.filename_template
@@ -157,11 +158,6 @@ class BaseSaver(SaverProtocol, abc.ABC):
         """Access the output directory for saving files."""
         return self._output_dir
 
-    @property
-    def raw_data_dir(self) -> Path:
-        """Access the raw data directory."""
-        return self._raw_data_dir
-
     @property
     def filename_template(self) -> str:
         """Access the filename template."""

novel_downloader/core/savers/common/epub.py

@@ -11,53 +11,30 @@ from __future__ import annotations
 import json
 from pathlib import Path
 from typing import TYPE_CHECKING
-from urllib.parse import unquote, urlparse
 
 from ebooklib import epub
 
 from novel_downloader.core.savers.epub_utils import (
+    add_images_from_dir,
     chapter_txt_to_html,
     create_css_items,
     create_volume_intro,
     generate_book_intro_html,
     init_epub,
+    inline_remote_images,
 )
 from novel_downloader.utils.constants import (
-    DEFAULT_IMAGE_SUFFIX,
     EPUB_OPTIONS,
     EPUB_TEXT_FOLDER,
 )
 from novel_downloader.utils.file_utils import sanitize_filename
+from novel_downloader.utils.network import download_image
 from novel_downloader.utils.text_utils import clean_chapter_title
 
 if TYPE_CHECKING:
     from .main_saver import CommonSaver
 
 
-def _image_url_to_filename(url: str) -> str:
-    """
-    Parse and sanitize a image filename from a URL.
-    If no filename or suffix exists, fallback to default name and extension.
-
-    :param url: URL string
-    :return: Safe filename string
-    """
-    if not url:
-        return ""
-
-    parsed_url = urlparse(url)
-    path = unquote(parsed_url.path)
-    filename = Path(path).name
-
-    if not filename:
-        filename = "image"
-
-    if not Path(filename).suffix:
-        filename += DEFAULT_IMAGE_SUFFIX
-
-    return filename
-
-
 def common_save_as_epub(
     saver: CommonSaver,
     book_id: str,
@@ -76,11 +53,12 @@ def common_save_as_epub(
     :param book_id: Identifier of the novel (used as subdirectory name).
     """
     TAG = "[saver]"
-    site = saver.site
     config = saver._config
     # --- Paths & options ---
-    raw_base = saver.raw_data_dir / site / book_id
+    raw_base = saver._raw_data_dir / book_id
+    img_dir = saver._cache_dir / book_id / "images"
     out_dir = saver.output_dir
+    img_dir.mkdir(parents=True, exist_ok=True)
     out_dir.mkdir(parents=True, exist_ok=True)
 
     # --- Load book_info.json ---
@@ -100,10 +78,16 @@ def common_save_as_epub(
     # --- Generate intro + cover ---
     intro_html = generate_book_intro_html(book_info)
     cover_path: Path | None = None
-    if config.include_cover:
-        cover_filename = _image_url_to_filename(book_info.get("cover_url", ""))
-        if cover_filename:
-            cover_path = raw_base / cover_filename
+    cover_url = book_info.get("cover_url", "")
+    if config.include_cover and cover_url:
+        cover_path = download_image(
+            cover_url,
+            raw_base,
+            target_name="cover",
+            on_exist="overwrite",
+        )
+        if not cover_path:
+            saver.logger.warning("Failed to download cover from %s", cover_url)
 
     # --- Initialize EPUB ---
     book, spine, toc_list = init_epub(
@@ -162,9 +146,11 @@ def common_save_as_epub(
                 continue
 
             title = clean_chapter_title(chapter_data.get("title", "")) or chap_id
+            content: str = chapter_data.get("content", "")
+            content = inline_remote_images(content, img_dir)
             chap_html = chapter_txt_to_html(
                 chapter_title=title,
-                chapter_text=chapter_data.get("content", ""),
+                chapter_text=content,
                 author_say=chapter_data.get("author_say", ""),
             )
 
@@ -182,6 +168,8 @@ def common_save_as_epub(
 
         toc_list.append((section, chapter_items))
 
+    book = add_images_from_dir(book, img_dir)
+
     # --- 5. Finalize EPUB ---
     saver.logger.info("%s Building TOC and spine...", TAG)
     book.toc = toc_list

novel_downloader/core/savers/common/main_saver.py

@@ -41,6 +41,8 @@ class CommonSaver(BaseSaver):
         """
         super().__init__(config)
         self._site = site
+        self._raw_data_dir = self._base_raw_data_dir / site
+        self._cache_dir = self._base_cache_dir / site
         self._chapter_storage_cache: dict[str, list[ChapterStorage]] = {}
         self._chap_folders: list[str] = chap_folders or ["chapters"]
 
@@ -109,7 +111,7 @@ class CommonSaver(BaseSaver):
         return {}
 
     def _init_chapter_storages(self, book_id: str) -> None:
-        raw_base = self.raw_data_dir / self._site / book_id
+        raw_base = self._raw_data_dir / book_id
         self._chapter_storage_cache[book_id] = [
             ChapterStorage(
                 raw_base=raw_base,

novel_downloader/core/savers/common/txt.py

@@ -45,9 +45,8 @@ def common_save_as_txt(
     :param book_id: Identifier of the novel (used as subdirectory name).
     """
     TAG = "[saver]"
-    site = saver.site
     # --- Paths & options ---
-    raw_base = saver.raw_data_dir / site / book_id
+    raw_base = saver._raw_data_dir / book_id
     out_dir = saver.output_dir
     out_dir.mkdir(parents=True, exist_ok=True)
 

novel_downloader/core/savers/epub_utils/__init__.py

@@ -6,21 +6,30 @@ novel_downloader.core.savers.epub_utils
 This package provides utility functions for constructing EPUB files,
 including:
 
-- CSS inclusion (create_css_items)
-- EPUB book initialization (init_epub)
-- Chapter text-to-HTML conversion (chapter_txt_to_html)
-- Volume intro HTML generation (create_volume_intro)
+- CSS inclusion (css_builder)
+- Image embedding (image_loader)
+- EPUB book initialization (initializer)
+- Chapter text-to-HTML conversion (text_to_html)
+- Volume intro HTML generation (volume_intro)
 """
 
 from .css_builder import create_css_items
+from .image_loader import add_images_from_dir, add_images_from_dirs
 from .initializer import init_epub
-from .text_to_html import chapter_txt_to_html, generate_book_intro_html
+from .text_to_html import (
+    chapter_txt_to_html,
+    generate_book_intro_html,
+    inline_remote_images,
+)
 from .volume_intro import create_volume_intro
 
 __all__ = [
     "create_css_items",
+    "add_images_from_dir",
+    "add_images_from_dirs",
     "init_epub",
     "chapter_txt_to_html",
     "create_volume_intro",
     "generate_book_intro_html",
+    "inline_remote_images",
 ]

novel_downloader/core/savers/epub_utils/css_builder.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.core.savers.epub_utils.css_builder
+---------------------------------------------------
 
 Reads local CSS files and wraps them into epub.EpubItem objects,
 returning a list ready to be added to the EPUB.

novel_downloader/core/savers/epub_utils/image_loader.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.savers.epub_utils.image_loader
+----------------------------------------------------
+
+Utilities for embedding image files into an EpubBook.
+"""
+
+import logging
+from collections.abc import Iterable
+from pathlib import Path
+
+from ebooklib import epub
+
+from novel_downloader.utils.constants import EPUB_IMAGE_FOLDER
+
+logger = logging.getLogger(__name__)
+
+_SUPPORTED_IMAGE_MEDIA_TYPES: dict[str, str] = {
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "svg": "image/svg+xml",
+    "webp": "image/webp",
+}
+_DEFAULT_IMAGE_MEDIA_TYPE = "image/jpeg"
+
+
+def add_images_from_dir(
+    book: epub.EpubBook,
+    image_dir: str | Path,
+) -> epub.EpubBook:
+    """
+    Load every file in `image_dir` into the EPUB's image folder.
+
+    :param book: The EpubBook object to modify.
+    :param image_dir: Path to the directory containing image files.
+    :return: The same EpubBook instance, with images added.
+    """
+    image_dir = Path(image_dir)
+    if not image_dir.is_dir():
+        logger.warning("Image directory not found or not a directory: %s", image_dir)
+        return book
+
+    for img_path in image_dir.iterdir():
+        if not img_path.is_file():
+            continue
+
+        suffix = img_path.suffix.lower().lstrip(".")
+        media_type = _SUPPORTED_IMAGE_MEDIA_TYPES.get(suffix)
+        if media_type is None:
+            media_type = _DEFAULT_IMAGE_MEDIA_TYPE
+            logger.warning(
+                "Unknown image suffix '%s' - defaulting media_type to %s",
+                suffix,
+                media_type,
+            )
+
+        try:
+            content = img_path.read_bytes()
+            item = epub.EpubItem(
+                uid=f"img_{img_path.stem}",
+                file_name=f"{EPUB_IMAGE_FOLDER}/{img_path.name}",
+                media_type=media_type,
+                content=content,
+            )
+            book.add_item(item)
+            logger.info("Embedded image: %s", img_path.name)
+        except Exception:
+            logger.exception("Failed to embed image %s", img_path)
+
+    return book
+
+
+def add_images_from_dirs(
+    book: epub.EpubBook,
+    image_dirs: Iterable[str | Path],
+) -> epub.EpubBook:
+    """
+    Add all images from multiple directories into the given EpubBook.
+
+    :param book: The EpubBook object to modify.
+    :param image_dirs: An iterable of directory paths to scan for images.
+    :return: The same EpubBook instance, with all images added.
+    """
+    for img_dir in image_dirs:
+        book = add_images_from_dir(book, img_dir)
+    return book

novel_downloader/core/savers/epub_utils/initializer.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.core.savers.epub_utils.initializer
+---------------------------------------------------
 
 Initializes an epub.EpubBook object, sets metadata
 (identifier, title, author, language, description),

novel_downloader/core/savers/epub_utils/text_to_html.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.core.savers.epub_utils.text_to_html
+----------------------------------------------------
 
 Module for converting raw chapter text to formatted HTML,
 with automatic word correction and optional image/tag support.
@@ -8,13 +9,23 @@ with automatic word correction and optional image/tag support.
 
 import json
 import logging
+import re
+from pathlib import Path
 from typing import Any
 
-from novel_downloader.utils.constants import REPLACE_WORD_MAP_PATH
+from novel_downloader.utils.constants import (
+    EPUB_IMAGE_WRAPPER,
+    REPLACE_WORD_MAP_PATH,
+)
+from novel_downloader.utils.network import download_image
 from novel_downloader.utils.text_utils import diff_inline_display
 
 logger = logging.getLogger(__name__)
 
+_IMG_TAG_PATTERN = re.compile(
+    r'<img\s+[^>]*src=[\'"]([^\'"]+)[\'"][^>]*>', re.IGNORECASE
+)
+
 
 # Load and sort replacement map from JSON
 try:
@@ -87,6 +98,42 @@ def chapter_txt_to_html(
     return "\n".join(html_parts)
 
 
+def inline_remote_images(
+    content: str,
+    image_dir: str | Path,
+) -> str:
+    """
+    Download every remote <img src="…"> in `content` into `image_dir`,
+    and replace the original tag with EPUB_IMAGE_WRAPPER
+    pointing to the local filename.
+
+    :param content: HTML/text of the chapter containing <img> tags.
+    :param image_dir: Directory to save downloaded images into.
+    :return: Modified content with local image references.
+    """
+
+    def _replace(match: re.Match[str]) -> str:
+        url = match.group(1)
+        try:
+            # download_image returns a Path or None
+            local_path = download_image(
+                url, image_dir, target_name=None, on_exist="skip"
+            )
+            if not local_path:
+                logger.warning(
+                    "Failed to download image, leaving original tag: %s", url
+                )
+                return match.group(0)
+
+            # wrap with the EPUB_IMAGE_WRAPPER, inserting just the filename
+            return EPUB_IMAGE_WRAPPER.format(filename=local_path.name)
+        except Exception:
+            logger.exception("Error processing image URL: %s", url)
+            return match.group(0)
+
+    return _IMG_TAG_PATTERN.sub(_replace, content)
+
+
 def generate_book_intro_html(book_info: dict[str, Any]) -> str:
     """
     Generate HTML string for a book's information and summary.

novel_downloader/core/savers/epub_utils/volume_intro.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.core.savers.epub_utils.volume_intro
+----------------------------------------------------
 
 Responsible for generating HTML code for volume introduction pages,
 including two style variants and a unified entry point.

novel_downloader/core/savers/esjzone.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.savers.esjzone
+------------------------------------
+
+"""
+
+from novel_downloader.config.models import SaverConfig
+
+from .common import CommonSaver
+
+
+class EsjzoneSaver(CommonSaver):
+    def __init__(
+        self,
+        config: SaverConfig,
+    ):
+        super().__init__(
+            config,
+            site="esjzone",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["EsjzoneSaver"]