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

novel_downloader/core/exporters/qianbi.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.qianbi
+--------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class QianbiExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="qianbi",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["QianbiExporter"]

novel_downloader/core/{savers → exporters}/qidian.py

@@ -1,22 +1,22 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.savers.qidian
------------------------------------
+novel_downloader.core.exporters.qidian
+--------------------------------------
 
-This module provides the `QidianSaver` class for handling the saving process
+This module provides the `QidianExporter` class for handling the saving process
 of novels sourced from Qidian (起点中文网). It implements the platform-specific
 logic required to structure and export novel content into desired formats.
 """
 
-from novel_downloader.config.models import SaverConfig
+from novel_downloader.models import ExporterConfig
 
-from .common import CommonSaver
+from .common import CommonExporter
 
 
-class QidianSaver(CommonSaver):
+class QidianExporter(CommonExporter):
     def __init__(
         self,
-        config: SaverConfig,
+        config: ExporterConfig,
     ):
         super().__init__(
             config,
@@ -25,4 +25,4 @@ class QidianSaver(CommonSaver):
         )
 
 
-__all__ = ["QidianSaver"]
+__all__ = ["QidianExporter"]

novel_downloader/core/exporters/sfacg.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.sfacg
+-------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class SfacgExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="sfacg",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["SfacgExporter"]

novel_downloader/core/exporters/yamibo.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.yamibo
+--------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class YamiboExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="yamibo",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["YamiboExporter"]

novel_downloader/core/factory/__init__.py

@@ -7,26 +7,14 @@ This package provides factory methods for dynamically retrieving components
 based on runtime parameters such as site name or content type.
 """
 
-from .downloader import (
-    get_async_downloader,
-    get_downloader,
-    get_sync_downloader,
-)
+from .downloader import get_downloader
+from .exporter import get_exporter
+from .fetcher import get_fetcher
 from .parser import get_parser
-from .requester import (
-    get_async_requester,
-    get_requester,
-    get_sync_requester,
-)
-from .saver import get_saver
 
 __all__ = [
-    "get_async_downloader",
     "get_downloader",
-    "get_sync_downloader",
+    "get_exporter",
+    "get_fetcher",
     "get_parser",
-    "get_async_requester",
-    "get_requester",
-    "get_sync_requester",
-    "get_saver",
 ]

novel_downloader/core/factory/downloader.py

@@ -1,60 +1,42 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.factory.downloader_factory
-------------------------------------------------
+novel_downloader.core.factory.downloader
+----------------------------------------
 
 This module implements a factory function for creating downloader instances
 based on the site name and parser mode specified in the configuration.
 """
 
 from collections.abc import Callable
-from typing import cast
 
-from novel_downloader.config import DownloaderConfig, load_site_rules
+from novel_downloader.config import load_site_rules
 from novel_downloader.core.downloaders import (
-    BiqugeAsyncDownloader,
     BiqugeDownloader,
-    CommonAsyncDownloader,
     CommonDownloader,
-    EsjzoneAsyncDownloader,
     EsjzoneDownloader,
-    QianbiAsyncDownloader,
+    LinovelibDownloader,
     QianbiDownloader,
     QidianDownloader,
-    SfacgAsyncDownloader,
     SfacgDownloader,
-    YamiboAsyncDownloader,
     YamiboDownloader,
 )
 from novel_downloader.core.interfaces import (
-    AsyncDownloaderProtocol,
-    AsyncRequesterProtocol,
+    DownloaderProtocol,
+    ExporterProtocol,
+    FetcherProtocol,
     ParserProtocol,
-    SaverProtocol,
-    SyncDownloaderProtocol,
-    SyncRequesterProtocol,
 )
+from novel_downloader.models import DownloaderConfig
 
-AsyncDownloaderBuilder = Callable[
-    [AsyncRequesterProtocol, ParserProtocol, SaverProtocol, DownloaderConfig],
-    AsyncDownloaderProtocol,
+DownloaderBuilder = Callable[
+    [FetcherProtocol, ParserProtocol, ExporterProtocol, DownloaderConfig],
+    DownloaderProtocol,
 ]
 
-SyncDownloaderBuilder = Callable[
-    [SyncRequesterProtocol, ParserProtocol, SaverProtocol, DownloaderConfig],
-    SyncDownloaderProtocol,
-]
-
-_async_site_map: dict[str, AsyncDownloaderBuilder] = {
-    "biquge": BiqugeAsyncDownloader,
-    "esjzone": EsjzoneAsyncDownloader,
-    "qianbi": QianbiAsyncDownloader,
-    "sfacg": SfacgAsyncDownloader,
-    "yamibo": YamiboAsyncDownloader,
-}
-_sync_site_map: dict[str, SyncDownloaderBuilder] = {
+_site_map: dict[str, DownloaderBuilder] = {
     "biquge": BiqugeDownloader,
     "esjzone": EsjzoneDownloader,
+    "linovelib": LinovelibDownloader,
     "qianbi": QianbiDownloader,
     "qidian": QidianDownloader,
     "sfacg": SfacgDownloader,
@@ -62,117 +44,33 @@ _sync_site_map: dict[str, SyncDownloaderBuilder] = {
 }
 
 
-def get_async_downloader(
-    requester: AsyncRequesterProtocol,
-    parser: ParserProtocol,
-    saver: SaverProtocol,
-    site: str,
-    config: DownloaderConfig,
-) -> AsyncDownloaderProtocol:
-    """
-    Returns an AsyncDownloaderProtocol for the given site.
-
-    :param requester: Requester implementation
-    :param parser: Parser implementation
-    :param saver: Saver implementation
-    :param site: Site name (e.g., 'qidian')
-    :param config: Downloader configuration
-
-    :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
-    """
-    site_key = site.lower()
-
-    if not isinstance(requester, AsyncRequesterProtocol):
-        raise TypeError("Async mode requires an AsyncRequesterProtocol")
-
-    # site-specific
-    if site_key in _async_site_map:
-        return _async_site_map[site_key](requester, parser, saver, 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}")
-
-    return CommonAsyncDownloader(requester, parser, saver, config, site_key)
-
-
-def get_sync_downloader(
-    requester: SyncRequesterProtocol,
+def get_downloader(
+    fetcher: FetcherProtocol,
     parser: ParserProtocol,
-    saver: SaverProtocol,
+    exporter: ExporterProtocol,
     site: str,
     config: DownloaderConfig,
-) -> SyncDownloaderProtocol:
+) -> DownloaderProtocol:
     """
-    Returns a DownloaderProtocol for the given site.
-    First tries a site-specific downloader (e.g. QidianDownloader),
-    otherwise falls back to CommonDownloader.
+    Returns an DownloaderProtocol for the given site.
 
-    :param requester: Requester implementation
+    :param fetcher: Fetcher implementation
     :param parser: Parser implementation
-    :param saver: Saver implementation
+    :param exporter: Exporter implementation
     :param site: Site name (e.g., 'qidian')
     :param config: Downloader configuration
 
     :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
     """
     site_key = site.lower()
 
-    if not isinstance(requester, SyncRequesterProtocol):
-        raise TypeError("Sync mode requires a RequesterProtocol")
-
     # site-specific
-    if site_key in _sync_site_map:
-        return _sync_site_map[site_key](requester, parser, saver, config)
+    if site_key in _site_map:
+        return _site_map[site_key](fetcher, parser, exporter, config)
 
     # fallback
     site_rules = load_site_rules()
-    site_rule = site_rules.get(site_key)
-    if site_rule is None:
+    if site_key not in site_rules:
         raise ValueError(f"Unsupported site: {site}")
 
-    return CommonDownloader(requester, parser, saver, config, site_key)
-
-
-def get_downloader(
-    requester: AsyncRequesterProtocol | SyncRequesterProtocol,
-    parser: ParserProtocol,
-    saver: SaverProtocol,
-    site: str,
-    config: DownloaderConfig,
-) -> AsyncDownloaderProtocol | SyncDownloaderProtocol:
-    """
-    Dispatches to get_async_downloader if config.mode == 'async',
-    otherwise to get_sync_downloader.
-
-    :param requester: Requester implementation
-    :param parser: Parser implementation
-    :param saver: Saver implementation
-    :param site: Site name (e.g., 'qidian')
-    :param config: Downloader configuration
-
-    :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
-    """
-    if requester.is_async():
-        if config.mode.lower() != "async":
-            raise TypeError("Requester is async, but config.mode is not 'async'")
-        async_requester = cast(AsyncRequesterProtocol, requester)
-        return get_async_downloader(async_requester, parser, saver, site, config)
-    else:
-        if config.mode.lower() not in ("browser", "session"):
-            raise TypeError(
-                "Requester is sync, but config.mode is not 'browser' or 'session'"
-            )
-        sync_requester = cast(SyncRequesterProtocol, requester)
-        return get_sync_downloader(sync_requester, parser, saver, site, config)
+    return CommonDownloader(fetcher, parser, exporter, config, site_key)

novel_downloader/core/factory/exporter.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.factory.exporter
+--------------------------------------
+
+This module implements a factory function for creating exporter instances
+based on the site name.
+"""
+
+from collections.abc import Callable
+
+from novel_downloader.config import load_site_rules
+from novel_downloader.core.exporters import (
+    BiqugeExporter,
+    CommonExporter,
+    EsjzoneExporter,
+    LinovelibExporter,
+    QianbiExporter,
+    QidianExporter,
+    SfacgExporter,
+    YamiboExporter,
+)
+from novel_downloader.core.interfaces import ExporterProtocol
+from novel_downloader.models import ExporterConfig
+
+ExporterBuilder = Callable[[ExporterConfig], ExporterProtocol]
+
+_site_map: dict[str, ExporterBuilder] = {
+    "biquge": BiqugeExporter,
+    "esjzone": EsjzoneExporter,
+    "linovelib": LinovelibExporter,
+    "qianbi": QianbiExporter,
+    "qidian": QidianExporter,
+    "sfacg": SfacgExporter,
+    "yamibo": YamiboExporter,
+}
+
+
+def get_exporter(site: str, config: ExporterConfig) -> ExporterProtocol:
+    """
+    Returns a site-specific exporter instance.
+
+    :param site: Site name (e.g., 'qidian')
+    :param config: Configuration for the exporter
+    :return: An instance of a exporter class
+    """
+    site_key = site.lower()
+
+    # site-specific
+    if site_key in _site_map:
+        return _site_map[site_key](config)
+
+    # Fallback
+    site_rules = load_site_rules()
+    if site_key not in site_rules:
+        raise ValueError(f"Unsupported site: {site}")
+
+    return CommonExporter(config, site_key)

novel_downloader/core/factory/fetcher.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.factory.fetcher
+-------------------------------------
+
+This module implements a factory function for retrieving fetcher instances
+based on the target novel platform (site).
+"""
+
+from collections.abc import Callable
+
+from novel_downloader.config import load_site_rules
+from novel_downloader.core.fetchers import (
+    BiqugeBrowser,
+    BiqugeSession,
+    CommonBrowser,
+    CommonSession,
+    EsjzoneBrowser,
+    EsjzoneSession,
+    LinovelibBrowser,
+    LinovelibSession,
+    QianbiBrowser,
+    QianbiSession,
+    QidianBrowser,
+    QidianSession,
+    SfacgBrowser,
+    SfacgSession,
+    YamiboBrowser,
+    YamiboSession,
+)
+from novel_downloader.core.interfaces import FetcherProtocol
+from novel_downloader.models import FetcherConfig
+
+FetcherBuilder = Callable[[FetcherConfig], FetcherProtocol]
+
+_site_map: dict[str, dict[str, FetcherBuilder]] = {
+    "biquge": {
+        "browser": BiqugeBrowser,
+        "session": BiqugeSession,
+    },
+    "esjzone": {
+        "browser": EsjzoneBrowser,
+        "session": EsjzoneSession,
+    },
+    "linovelib": {
+        "browser": LinovelibBrowser,
+        "session": LinovelibSession,
+    },
+    "qianbi": {
+        "browser": QianbiBrowser,
+        "session": QianbiSession,
+    },
+    "qidian": {
+        "browser": QidianBrowser,
+        "session": QidianSession,
+    },
+    "sfacg": {
+        "browser": SfacgBrowser,
+        "session": SfacgSession,
+    },
+    "yamibo": {
+        "browser": YamiboBrowser,
+        "session": YamiboSession,
+    },
+}
+
+
+def get_fetcher(
+    site: str,
+    config: FetcherConfig,
+) -> FetcherProtocol:
+    """
+    Returns an FetcherProtocol 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()
+    mode = config.mode
+
+    # site-specific
+    fetcher_cls = _site_map.get(site_key, {}).get(mode)
+    if fetcher_cls is not None:
+        return fetcher_cls(config)
+
+    # fallback: use Common based on mode
+    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"]
+
+    if mode == "browser":
+        return CommonBrowser(site_key, profile, config)
+    return CommonSession(site_key, profile, config)

novel_downloader/core/factory/parser.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.factory.parser_factory
---------------------------------------------
+novel_downloader.core.factory.parser
+------------------------------------
 
 This module implements a factory function for creating parser instances
 based on the site name and parser mode specified in the configuration.
@@ -9,45 +9,50 @@ based on the site name and parser mode specified in the configuration.
 
 from collections.abc import Callable
 
-from novel_downloader.config import ParserConfig, load_site_rules
+from novel_downloader.config import load_site_rules
 from novel_downloader.core.interfaces import ParserProtocol
 from novel_downloader.core.parsers import (
     BiqugeParser,
     CommonParser,
     EsjzoneParser,
+    LinovelibParser,
     QianbiParser,
-    QidianBrowserParser,
-    QidianSessionParser,
+    QidianParser,
     SfacgParser,
     YamiboParser,
 )
+from novel_downloader.models import ParserConfig
 
 ParserBuilder = Callable[[ParserConfig], ParserProtocol]
 
 _site_map: dict[str, dict[str, ParserBuilder]] = {
     "biquge": {
+        "browser": BiqugeParser,
         "session": BiqugeParser,
-        "async": BiqugeParser,
     },
     "esjzone": {
+        "browser": EsjzoneParser,
         "session": EsjzoneParser,
-        "async": EsjzoneParser,
+    },
+    "linovelib": {
+        "browser": LinovelibParser,
+        "session": LinovelibParser,
     },
     "qianbi": {
+        "browser": QianbiParser,
         "session": QianbiParser,
-        "async": QianbiParser,
     },
     "qidian": {
-        "browser": QidianBrowserParser,
-        "session": QidianSessionParser,
+        "browser": QidianParser,
+        "session": QidianParser,
     },
     "sfacg": {
+        "browser": SfacgParser,
         "session": SfacgParser,
-        "async": SfacgParser,
     },
     "yamibo": {
+        "browser": YamiboParser,
         "session": YamiboParser,
-        "async": YamiboParser,
     },
 }
 

novel_downloader/core/{requesters → fetchers}/__init__.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters
---------------------------------
+novel_downloader.core.fetchers
+------------------------------
 
-This package provides requester implementations for different novel platforms.
+This package provides fetcher implementations for different novel platforms.
 Each submodule corresponds to a specific site and encapsulates the logic needed
 to perform network interactions, such as logging in, sending requests,
 or interacting with browser/session-based sources.
@@ -11,6 +11,7 @@ or interacting with browser/session-based sources.
 Subpackages:
 - biquge (笔趣阁)
 - esjzone (ESJ Zone)
+- linovelib (哔哩轻小说)
 - qianbi (铅笔小说)
 - qidian (起点中文网)
 - sfacg (SF轻小说)
@@ -19,19 +20,23 @@ Subpackages:
 """
 
 from .biquge import (
-    BiqugeAsyncSession,
+    BiqugeBrowser,
     BiqugeSession,
 )
 from .common import (
-    CommonAsyncSession,
+    CommonBrowser,
     CommonSession,
 )
 from .esjzone import (
-    EsjzoneAsyncSession,
+    EsjzoneBrowser,
     EsjzoneSession,
 )
+from .linovelib import (
+    LinovelibBrowser,
+    LinovelibSession,
+)
 from .qianbi import (
-    QianbiAsyncSession,
+    QianbiBrowser,
     QianbiSession,
 )
 from .qidian import (
@@ -39,27 +44,29 @@ from .qidian import (
     QidianSession,
 )
 from .sfacg import (
-    SfacgAsyncSession,
+    SfacgBrowser,
     SfacgSession,
 )
 from .yamibo import (
-    YamiboAsyncSession,
+    YamiboBrowser,
     YamiboSession,
 )
 
 __all__ = [
-    "BiqugeAsyncSession",
+    "BiqugeBrowser",
     "BiqugeSession",
-    "CommonAsyncSession",
+    "CommonBrowser",
     "CommonSession",
-    "EsjzoneAsyncSession",
+    "EsjzoneBrowser",
     "EsjzoneSession",
-    "QianbiAsyncSession",
+    "LinovelibBrowser",
+    "LinovelibSession",
+    "QianbiBrowser",
     "QianbiSession",
     "QidianBrowser",
     "QidianSession",
-    "SfacgAsyncSession",
+    "SfacgBrowser",
     "SfacgSession",
-    "YamiboAsyncSession",
+    "YamiboBrowser",
     "YamiboSession",
 ]

novel_downloader/core/{requesters → fetchers}/base/__init__.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.requesters.base
--------------------------------------
+novel_downloader.core.fetchers.base
+-----------------------------------
 
 """
 
-from .async_session import BaseAsyncSession
 from .browser import BaseBrowser
 from .session import BaseSession
 
 __all__ = [
-    "BaseAsyncSession",
     "BaseBrowser",
     "BaseSession",
 ]