novel-downloader 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

novel_downloader/utils/state.py

@@ -2,24 +2,22 @@
 """
 novel_downloader.utils.state
 ----------------------------
-State management for user preferences and runtime flags.
 
-Supported sections:
-- general: global preferences (e.g. language)
-- sites: per-site flags & data (e.g. manual_login, cookies)
+State management for user preferences and runtime flags.
 """
 
+__all__ = ["StateManager", "state_mgr"]
+
 import json
 from pathlib import Path
 from typing import Any
 
-from .constants import STATE_FILE
+from novel_downloader.utils.constants import STATE_FILE
 
 
 class StateManager:
     """
     Manages persistent state for user preferences and runtime flags.
-    Stores data in JSON at STATE_FILE.
     """
 
     def __init__(self, path: Path = STATE_FILE) -> None:
@@ -50,26 +48,6 @@ class StateManager:
         content = json.dumps(self._data, ensure_ascii=False, indent=2)
         self._path.write_text(content, encoding="utf-8")
 
-    def _parse_cookie_string(self, cookie_str: str) -> dict[str, str]:
-        """
-        Parse a Cookie header string into a dict.
-
-        :param cookie_str: e.g. 'k1=v1; k2=v2; k3'
-        :return: mapping cookie names to values (missing '=' yields empty string)
-        :rtype: Dict[str, str]
-        """
-        cookies: dict[str, str] = {}
-        for item in cookie_str.split(";"):
-            item = item.strip()
-            if not item:
-                continue
-            if "=" in item:
-                k, v = item.split("=", 1)
-                cookies[k.strip()] = v.strip()
-            else:
-                cookies[item] = ""
-        return cookies
-
     def get_language(self) -> str:
         """
         Load the user's language preference, defaulting to 'zh'.
@@ -88,69 +66,5 @@ class StateManager:
         self._data.setdefault("general", {})["lang"] = lang
         self._save()
 
-    def get_manual_login_flag(self, site: str) -> bool:
-        """
-        Retrieve the manual login requirement flag for a specific site.
-
-        :param site: Site identifier (e.g. 'qidian', 'bqg')
-        :return: True if manual login is required (defaults to True)
-        """
-        val = self._data.get("sites", {}).get(site, {}).get("manual_login", True)
-        return bool(val)
-
-    def set_manual_login_flag(self, site: str, flag: bool) -> None:
-        """
-        Set the 'manual_login' flag for a specific site.
-
-        :param flag: True if the site requires manual login.
-        :param site: Site identifier (e.g. 'qidian', 'bqg')
-        """
-        sites = self._data.setdefault("sites", {})
-        site_data = sites.setdefault(site, {})
-        site_data["manual_login"] = flag
-        self._save()
-
-    def get_cookies(self, site: str) -> dict[str, str]:
-        """
-        Retrieve the persisted cookies for a specific site.
-
-        :param site: Site identifier (e.g. 'qidian', 'bqg')
-        :return: A dict mapping cookie names to values. Returns empty dict if not set.
-        """
-        cookies = self._data.get("sites", {}).get(site, {}).get("cookies", {})
-        return {str(k): str(v) for k, v in cookies.items()}
-
-    def set_cookies(self, site: str, cookies: str | dict[str, str]) -> None:
-        """
-        Persist (overwrite) the cookies for a specific site.
-
-        :param site: Site identifier (e.g. 'qidian', 'bqg')
-        :param cookies: Either a dict mapping cookie names to values,
-                        or a string (JSON or 'k=v; k2=v2') to be parsed.
-        :raises TypeError: if cookies is neither str nor dict
-        """
-        # 1) normalize to dict
-        if isinstance(cookies, dict):
-            cookies_dict = cookies
-        elif isinstance(cookies, str):
-            # try JSON first
-            try:
-                parsed = json.loads(cookies)
-                if isinstance(parsed, dict):
-                    cookies_dict = parsed  # OK!
-                else:
-                    raise ValueError
-            except Exception:
-                # fallback to "k=v; k2=v2" format
-                cookies_dict = self._parse_cookie_string(cookies)
-        else:
-            raise TypeError("`cookies` must be a dict or a str")
-
-        # 2) persist
-        sites = self._data.setdefault("sites", {})
-        site_data = sites.setdefault(site, {})
-        site_data["cookies"] = {str(k): str(v) for k, v in cookies_dict.items()}
-        self._save()
-
 
 state_mgr = StateManager()

novel_downloader/utils/text_utils/__init__.py

@@ -3,13 +3,7 @@
 novel_downloader.utils.text_utils
 ---------------------------------
 
-Utility modules for text formatting, font mapping, cleaning, and diff display.
-
-Submodules:
-- diff_display: Generate inline diffs with aligned character markers
-- numeric_conversion: Convert between Chinese and Arabic numerals
-- text_cleaner: Text cleaning and normalization utilities
-- truncate_utils: Text truncation and content prefix generation
+Utility modules for text formatting, cleaning, and diff display.
 """
 
 __all__ = [

novel_downloader/utils/text_utils/diff_display.py

@@ -6,9 +6,7 @@ novel_downloader.utils.text_utils.diff_display
 Generate inline character-level diff between two strings with visual markers.
 """
 
-__all__ = [
-    "diff_inline_display",
-]
+__all__ = ["diff_inline_display"]
 
 import difflib
 import unicodedata
@@ -22,10 +20,10 @@ def _char_width_space(
 
     Fullwidth (F) or Wide (W) characters map to `asian_char`, else `normal_char`.
 
-    :param c:           A single character.
+    :param c: A single character.
     :param normal_char: Replacement for narrow chars (default U+0020).
-    :param asian_char:  Replacement for wide chars (default U+3000).
-    :return:            The appropriate space character.
+    :param asian_char: Replacement for wide chars (default U+3000).
+    :return: The appropriate space character.
     """
     return asian_char if unicodedata.east_asian_width(c) in ("F", "W") else normal_char
 
@@ -37,7 +35,7 @@ def diff_inline_display(old_str: str, new_str: str) -> str:
 
     :param old_str: Original string (prefixed '-' will be trimmed).
     :param new_str: Modified string (prefixed '+' will be trimmed).
-    :return:        A multiline diff display with aligned markers.
+    :return: A multiline diff display with aligned markers.
     """
     space_1 = " "
     space_2 = "\u3000"

novel_downloader/utils/time_utils/__init__.py

@@ -4,19 +4,13 @@ novel_downloader.utils.time_utils
 ---------------------------------
 
 Utility functions for time and date-related operations.
-
-Includes:
-- calculate_time_difference:
-    Computes time delta between two timezone-aware datetime strings.
-- sleep_with_random_delay:
-    Sleeps for a random duration, useful for human-like delays or rate limiting.
 """
 
 __all__ = [
-    "calculate_time_difference",
-    "async_sleep_with_random_delay",
-    "sleep_with_random_delay",
+    "time_diff",
+    "async_jitter_sleep",
+    "jitter_sleep",
 ]
 
-from .datetime_utils import calculate_time_difference
-from .sleep_utils import async_sleep_with_random_delay, sleep_with_random_delay
+from .datetime_utils import time_diff
+from .sleep_utils import async_jitter_sleep, jitter_sleep

novel_downloader/utils/time_utils/datetime_utils.py

@@ -4,16 +4,10 @@ novel_downloader.utils.time_utils.datetime_utils
 ------------------------------------------------
 
 Time utility functions for timezone-aware date calculations.
-
-Includes:
-- _parse_utc_offset():
-    Converts UTC offset string (e.g. 'UTC+8') to a timezone object.
-- calculate_time_difference():
-    Computes timedelta between two datetime strings, with optional timezones.
 """
 
 __all__ = [
-    "calculate_time_difference",
+    "time_diff",
 ]
 
 import logging
@@ -53,7 +47,7 @@ def _parse_utc_offset(tz_str: str) -> timezone:
     Parse a timezone string like 'UTC+8' or 'UTC-5' into a datetime.timezone object.
 
     :param tz_str: Timezone in 'UTC±<hours>' format, e.g. 'UTC', 'UTC+8', 'UTC-05'
-    :return:       Corresponding timezone object
+    :return: Corresponding timezone object
     :raises ValueError: if tz_str is not a valid UTC offset format
     """
     tz_str_clean = tz_str.upper().strip()
@@ -74,20 +68,20 @@ def _parse_datetime_flexible(dt_str: str) -> datetime:
     """
     Parse a date/time string in any of several common formats:
 
-      • ISO 8601:             'YYYY-MM-DDTHH:MM:SSZ'
-      • ISO w/ offset:        'YYYY-MM-DDTHH:MM:SS+HH:MM'
-      • 'YYYY-MM-DD HH:MM:SS'
-      • 'YYYY-MM-DD'          (time defaults to 00:00:00)
-      • 'YYYY/MM/DD HH:MM:SS'
-      • 'YYYY/MM/DD HH:MM'
-      • 'YYYY/MM/DD'
-      • 'MM/DD/YYYY HH:MM[:SS] AM/PM'
-      • 'MM/DD/YYYY'
-      • 'DD.MM.YYYY HH:MM'
-      • 'DD.MM.YYYY'
+      * ISO 8601:             'YYYY-MM-DDTHH:MM:SSZ'
+      * ISO w/ offset:        'YYYY-MM-DDTHH:MM:SS+HH:MM'
+      * 'YYYY-MM-DD HH:MM:SS'
+      * 'YYYY-MM-DD'          (time defaults to 00:00:00)
+      * 'YYYY/MM/DD HH:MM:SS'
+      * 'YYYY/MM/DD HH:MM'
+      * 'YYYY/MM/DD'
+      * 'MM/DD/YYYY HH:MM[:SS] AM/PM'
+      * 'MM/DD/YYYY'
+      * 'DD.MM.YYYY HH:MM'
+      * 'DD.MM.YYYY'
 
     :param dt_str: Date/time string to parse.
-    :return:       A naive datetime object.
+    :return: A naive datetime object.
     :raises ValueError: If dt_str does not match the expected formats.
     """
     s = dt_str.strip()
@@ -95,13 +89,10 @@ def _parse_datetime_flexible(dt_str: str) -> datetime:
         if re.fullmatch(pattern, s):
             return datetime.strptime(s, fmt)
 
-    supported = "\n".join(f"  • {fmt}" for _, fmt in _DATETIME_FORMATS)
-    raise ValueError(
-        f"Invalid date/time format: '{dt_str}'\n" f"Supported formats are:\n{supported}"
-    )
+    raise ValueError(f"Invalid date/time format: '{dt_str}'")
 
 
-def calculate_time_difference(
+def time_diff(
     from_time_str: str,
     tz_str: str = "UTC",
     to_time_str: str | None = None,
@@ -111,10 +102,10 @@ def calculate_time_difference(
     Calculate the difference between two datetime values.
 
     :param from_time_str: Date-time string "YYYY-MM-DD HH:MM:SS" for the start.
-    :param tz_str:        Timezone of from_time_str, e.g. 'UTC+8'. Defaults to 'UTC'.
-    :param to_time_str:   Optional date-time string for the end; if None, uses now().
-    :param to_tz_str:     Timezone of to_time_str. Defaults to 'UTC'.
-    :return:              Tuple (days, hours, minutes, seconds).
+    :param tz_str: Timezone of from_time_str, e.g. 'UTC+8'. Defaults to 'UTC'.
+    :param to_time_str: Optional date-time string for the end; if None, uses now().
+    :param to_tz_str: Timezone of to_time_str. Defaults to 'UTC'.
+    :return: Tuple (days, hours, minutes, seconds).
     """
     try:
         # parse start time

novel_downloader/utils/time_utils/sleep_utils.py

@@ -4,13 +4,9 @@ novel_downloader.utils.time_utils.sleep_utils
 ---------------------------------------------
 
 Utilities for adding randomized delays in scripts and bots.
-
-Includes:
-- sleep_with_random_delay(): Sleep between base and base+spread seconds,
-  optionally capped with a max_sleep limit.
 """
 
-__all__ = ["sleep_with_random_delay", "async_sleep_with_random_delay"]
+__all__ = ["jitter_sleep", "async_jitter_sleep"]
 
 import asyncio
 import logging
@@ -20,7 +16,7 @@ import time
 logger = logging.getLogger(__name__)
 
 
-def sleep_with_random_delay(
+def jitter_sleep(
     base: float,
     add_spread: float = 0.0,
     mul_spread: float = 1.0,
@@ -41,7 +37,7 @@ def sleep_with_random_delay(
     :param mul_spread: Maximum multiplier factor for base; drawn from [1.0, mul_spread].
     :param max_sleep: Optional upper limit for the final sleep duration.
     """
-    if base < 0 or add_spread < 0 or mul_spread < 0:
+    if base < 0 or add_spread < 0 or mul_spread < 1.0:
         logger.warning(
             "[sleep] Invalid parameters: base=%s, add_spread=%s, mul_spread=%s",
             base,
@@ -63,7 +59,7 @@ def sleep_with_random_delay(
     return
 
 
-async def async_sleep_with_random_delay(
+async def async_jitter_sleep(
     base: float,
     add_spread: float = 0.0,
     mul_spread: float = 1.0,

novel_downloader/web/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web
+--------------------
+
+This module exposes the WEB entry point.
+"""
+
+__all__ = [
+    "web_main",
+]
+
+from .main import web_main

novel_downloader/web/components/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web.components
+-------------------------------
+
+Entry point for reusable web UI components
+"""
+
+__all__ = ["navbar"]
+
+from .navigation import navbar

novel_downloader/web/components/navigation.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web.components.navigation
+------------------------------------------
+
+A tiny NiceGUI component that renders the app's top navigation bar
+"""
+
+from nicegui import ui
+
+
+def navbar(active: str) -> None:
+    """
+    Render the site-wide navigation header.
+
+    :param active: Key of the current page to highlight.
+    """
+    with (
+        ui.header().classes("px-3 items-center justify-between bg-primary text-white"),
+        ui.row().classes("items-center gap-2 flex-wrap"),
+    ):
+        _nav_btn("搜索", "/", active == "search", icon="search")
+        _nav_btn("下载", "/download", active == "download", icon="download")
+        _nav_btn("正在下载", "/progress", active == "progress", icon="cloud_download")
+
+
+def _nav_btn(label: str, path: str, is_active: bool, icon: str | None = None) -> None:
+    if is_active:
+        ui.button(label, icon=icon, on_click=lambda: ui.navigate.to(path)).props(
+            "unelevated color=white text-color=primary"
+        )
+    else:
+        ui.button(label, icon=icon, on_click=lambda: ui.navigate.to(path)).props(
+            "flat text-color=white"
+        )

novel_downloader/web/main.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web.main
+-------------------------
+
+Novel Downloader web UI (NiceGUI).
+
+This entry point starts the local server and registers the app's pages.
+"""
+
+import argparse
+from pathlib import Path
+
+from nicegui import app, ui
+
+import novel_downloader.web.pages  # noqa: F401
+from novel_downloader.config import get_config_value
+from novel_downloader.utils.logger import setup_logging
+
+
+def mount_exports() -> None:
+    output_dir = get_config_value(["general", "output_dir"], "./downloads")
+    out = Path(output_dir).expanduser().resolve()
+    out.mkdir(parents=True, exist_ok=True)
+    # serves /download/<filename> from the export dir
+    app.add_static_files("/download", local_directory=out)
+
+
+def web_main() -> None:
+    p = argparse.ArgumentParser(
+        description="Novel Downloader web UI.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument(
+        "--listen",
+        choices=["local", "public"],
+        default="local",
+        help=(
+            "Bind address mode: 'local' binds to 127.0.0.1; "
+            "'public' binds to 0.0.0.0."
+        ),
+    )
+    p.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="TCP port to serve the app on.",
+    )
+    p.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable autoreload on code changes (development).",
+    )
+    args = p.parse_args()
+
+    host = "127.0.0.1" if args.listen == "local" else "0.0.0.0"
+
+    log_level = get_config_value(["general", "debug", "log_level"], "INFO")
+    setup_logging(log_level=log_level)
+
+    app.on_startup(mount_exports)
+    ui.run(host=host, port=args.port, reload=args.reload)
+
+
+if __name__ in {"__main__", "__mp_main__"}:
+    web_main()

novel_downloader/web/pages/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web.pages
+--------------------------
+
+NiceGUI page registrations; importing this package exposes and registers all routes.
+"""
+
+__all__ = [
+    "page_download",  # /download
+    "page_progress",  # /progress
+    "page_search",  # /
+]
+
+from .download import page_download
+from .progress import page_progress
+from .search import page_search

novel_downloader/web/pages/download.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.web.pages.download
+-----------------------------------
+
+"""
+
+from nicegui import ui
+
+from novel_downloader.web.components import navbar
+from novel_downloader.web.services import manager, setup_dialog
+
+_SUPPORT_SITES = {
+    "aaatxt": "3A电子书 (aaatxt)",
+    "biquge": "笔趣阁 (biquge)",
+    "biquyuedu": "精彩小说 (biquyuedu)",
+    "dxmwx": "大熊猫文学网 (dxmwx)",
+    "eightnovel": "无限轻小说 (8novel)",
+    "esjzone": "ESJ Zone (esjzone)",
+    "guidaye": "名著阅读 (guidaye)",
+    "hetushu": "和图书 (hetushu)",
+    "i25zw": "25中文网 (i25zw)",
+    "ixdzs8": "爱下电子书 (ixdzs8)",
+    "jpxs123": "精品小说网 (jpxs123)",
+    "lewenn": "乐文小说网 (lewenn)",
+    "linovelib": "哔哩轻小说 (linovelib)",
+    "piaotia": "飘天文学网 (piaotia)",
+    "qbtr": "全本同人小说 (qbtr)",
+    "qianbi": "铅笔小说 (qianbi)",
+    "qidian": "起点中文网 (qidian)",
+    "quanben5": "全本小说网 (quanben5)",
+    "sfacg": "SF轻小说 (sfacg)",
+    "shencou": "神凑轻小说 (shencou)",
+    "shuhaige": "书海阁小说网 (shuhaige)",
+    "tongrenquan": "同人圈 (tongrenquan)",
+    "ttkan": "天天看小说 (ttkan)",
+    "wanbengo": "完本神站 (wanbengo)",
+    "xiaoshuowu": "小说屋 (xiaoshuowu)",
+    "xiguashuwu": "西瓜书屋 (xiguashuwu)",
+    "xs63b": "小说路上 (xs63b)",
+    "xshbook": "小说虎 (xshbook)",
+    "yamibo": "百合会 (yamibo)",
+    "yibige": "一笔阁 (yibige)",
+}
+_DEFAULT_SITE = "qidian"
+
+
+@ui.page("/download")  # type: ignore[misc]
+def page_download() -> None:
+    navbar("download")
+    ui.label("下载界面").classes("text-lg")
+    setup_dialog()
+
+    with ui.card().classes("max-w-[600px]"):
+        site = ui.select(
+            _SUPPORT_SITES,
+            value=_DEFAULT_SITE,
+            label="站点",
+            with_input=True,
+        ).classes("w-full")
+
+        book_id = ui.input("书籍ID").props("outlined dense").classes("w-full")
+
+        async def add_task() -> None:
+            bid = (book_id.value or "").strip()
+            if not bid:
+                ui.notify("请输入书籍ID", type="warning")
+                return
+            title = f"{site.value} (id = {bid})"
+            ui.notify(f"已添加任务: {title}")
+            await manager.add_task(title=title, site=str(site.value), book_id=bid)
+
+        with ui.row().classes("justify-end w-full"):
+            ui.button(
+                "添加到下载队列",
+                on_click=add_task,
+                color="primary",
+            ).props("unelevated")