novel-downloader 1.5.0__py3-none-any.whl → 2.0.1__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/text_utils/text_cleaner.py

@@ -42,7 +42,7 @@ class TextCleaner(Cleaner):
     TextCleaner removes invisible characters, strips unwanted patterns,
     and applies literal replacements in a single pass using a combined regex.
 
-    For regex that never matches, reference:
+    For regex that never matches (r"$^"), reference:
 
     https://stackoverflow.com/questions/2930182/regex-to-not-match-anything
     """
@@ -53,13 +53,14 @@ class TextCleaner(Cleaner):
         """
         Initialize TextCleaner with the given configuration.
 
-        :param config: TextCleanerConfig instance containing:
+        Configuration fields (from ``TextCleanerConfig``):
+          * remove_invisible: whether to strip BOM/zero-width chars
+          * title_remove_patterns: list of regex patterns to delete from titles
+          * content_remove_patterns: list of regex patterns to delete from content
+          * title_replacements: dict of literal replacements for titles
+          * content_replacements: dict of literal replacements for content
 
-            - remove_invisible: whether to strip BOM/zero-width chars
-            - title_remove_patterns: list of regex patterns to delete from titles
-            - content_remove_patterns: list of regex patterns to delete from content
-            - title_replacements: dict of literal replacements for titles
-            - content_replacements: dict of literal replacements for content
+        :param config: A ``TextCleanerConfig`` instance.
         """
         self._remove_invisible = config.remove_invisible
 
@@ -73,20 +74,23 @@ class TextCleaner(Cleaner):
 
         # Build a single combined regex for title:
         #   all delete‐patterns OR all escaped replacement‐keys
-        title_parts = title_remove + [re.escape(k) for k in self._title_repl_map]
-        title_parts.sort(
-            key=len, reverse=True
-        )  # longer first to avoid prefix collisions
-        title_pattern = "|".join(title_parts) if title_parts else r"$^"
-        self._title_combined_rx: Pattern[str] = re.compile(title_pattern)
+        self._title_combined_rx: re.Pattern[str] | None = None
+        if title_remove or self._title_repl_map:
+            title_parts = title_remove + [re.escape(k) for k in self._title_repl_map]
+            # longer first to avoid prefix collisions
+            title_parts.sort(key=len, reverse=True)
+            self._title_combined_rx = re.compile("|".join(title_parts))
 
         # Build a single combined regex for content (multiline mode)
-        content_parts = content_remove + [re.escape(k) for k in self._content_repl_map]
-        content_parts.sort(key=len, reverse=True)
-        content_pattern = "|".join(content_parts) if content_parts else r"$^"
-        self._content_combined_rx: Pattern[str] = re.compile(
-            content_pattern, flags=re.MULTILINE
-        )
+        self._content_combined_rx: re.Pattern[str] | None = None
+        if content_remove or self._content_repl_map:
+            content_parts = content_remove + [
+                re.escape(k) for k in self._content_repl_map
+            ]
+            content_parts.sort(key=len, reverse=True)
+            self._content_combined_rx = re.compile(
+                "|".join(content_parts), flags=re.MULTILINE
+            )
 
     def clean_title(self, text: str) -> str:
         """
@@ -132,11 +136,11 @@ class TextCleaner(Cleaner):
         Remove BOM and zero-width/invisible characters from the text.
 
         Matches:
-          - U+FEFF (BOM)
-          - U+200B ZERO WIDTH SPACE
-          - U+200C ZERO WIDTH NON-JOINER
-          - U+200D ZERO WIDTH JOINER
-          - U+2060 WORD JOINER
+          * U+FEFF (BOM)
+          * U+200B ZERO WIDTH SPACE
+          * U+200C ZERO WIDTH NON-JOINER
+          * U+200D ZERO WIDTH JOINER
+          * U+2060 WORD JOINER
 
         :param text: Input string possibly containing invisible chars.
         :return: String with those characters stripped.
@@ -146,7 +150,7 @@ class TextCleaner(Cleaner):
     def _do_clean(
         self,
         text: str,
-        combined_rx: Pattern[str],
+        combined_rx: Pattern[str] | None,
         repl_map: dict[str, str],
     ) -> str:
         """
@@ -158,17 +162,22 @@ class TextCleaner(Cleaner):
         :param repl_map: Mapping from matched token to replacement text.
         :return: Cleaned text.
         """
+        if not self._remove_invisible and not combined_rx:
+            return text.strip()
+
         # Strip invisible chars if configured
         if self._remove_invisible:
             text = self._remove_bom_and_invisible(text)
 
         # Single‐pass removal & replacement
-        def _sub(match: Match[str]) -> str:
-            token = match.group(0)
-            # If token in repl_map -> replacement; else -> delete (empty string)
-            return repl_map.get(token, "")
+        if combined_rx:
+
+            def _sub(match: Match[str]) -> str:
+                # If token in repl_map -> replacement; else -> delete (empty string)
+                return repl_map.get(match.group(0), "")
+
+            text = combined_rx.sub(_sub, text)
 
-        text = combined_rx.sub(_sub, text)
         return text.strip()
 
 

novel_downloader/utils/text_utils/truncate_utils.py

@@ -11,8 +11,6 @@ __all__ = [
     "truncate_half_lines",
 ]
 
-import math
-
 
 def content_prefix(
     text: str,
@@ -41,22 +39,13 @@ def content_prefix(
 
 def truncate_half_lines(text: str) -> str:
     """
-    Keep the first half of the lines (rounded up), preserving line breaks.
+    Keep the first half of the lines.
 
     :param text: Full input text
     :return: Truncated text with first half of lines
     """
     lines = text.splitlines()
     non_empty_lines = [line for line in lines if line.strip()]
-    keep_count = math.ceil(len(non_empty_lines) / 2)
-
-    result_lines = []
-    count = 0
-    for line in lines:
-        result_lines.append(line)
-        if line.strip():
-            count += 1
-        if count >= keep_count:
-            break
-
+    keep_count = (len(non_empty_lines) + 1) // 2
+    result_lines = non_empty_lines[:keep_count]
     return "\n".join(result_lines)

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,50 +16,51 @@ import time
 logger = logging.getLogger(__name__)
 
 
-def sleep_with_random_delay(
+def _calc_sleep_duration(
     base: float,
-    add_spread: float = 0.0,
-    mul_spread: float = 1.0,
-    *,
+    add_spread: float,
+    mul_spread: float,
     max_sleep: float | None = None,
-) -> None:
+    *,
+    log_prefix: str = "sleep",
+) -> float | None:
     """
-    Sleep for a random duration by combining multiplicative and additive jitter.
-
-    The total sleep time is computed as:
-
-        duration = base * uniform(1.0, mul_spread) + uniform(0, add_spread)
+    Compute the jittered sleep duration (in seconds) or return None if params invalid.
 
-    If `max_sleep` is provided, the duration will be capped at that value.
+      duration = base * uniform(1.0, mul_spread) + uniform(0, add_spread)
 
-    :param base: Base sleep time in seconds. Must be >= 0.
-    :param add_spread: Maximum extra seconds to add after scaling base.
-    :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.
+    then optionally capped by max_sleep.
     """
-    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",
+            "[%s] Invalid parameters: base=%s, add_spread=%s, mul_spread=%s",
+            log_prefix,
             base,
             add_spread,
             mul_spread,
         )
-        return
+        return None
 
-    # Calculate the raw duration
     multiplicative_jitter = random.uniform(1.0, mul_spread)
-    additive_jitter = random.uniform(0, add_spread)
+    additive_jitter = random.uniform(0.0, add_spread)
     duration = base * multiplicative_jitter + additive_jitter
 
     if max_sleep is not None:
         duration = min(duration, max_sleep)
 
-    logger.debug("[time] Sleeping for %.2f seconds", duration)
-    time.sleep(duration)
-    return
+    logger.debug(
+        "[%s] base=%.3f mul=%.3f add=%.3f max=%s -> duration=%.3f",
+        log_prefix,
+        base,
+        multiplicative_jitter,
+        additive_jitter,
+        max_sleep,
+        duration,
+    )
+    return duration
 
 
-async def async_sleep_with_random_delay(
+def jitter_sleep(
     base: float,
     add_spread: float = 0.0,
     mul_spread: float = 1.0,
@@ -71,34 +68,43 @@ async def async_sleep_with_random_delay(
     max_sleep: float | None = None,
 ) -> None:
     """
-    Async sleep for a random duration by combining multiplicative and additive jitter.
-
-    The total sleep time is computed as:
-
-        duration = base * uniform(1.0, mul_spread) + uniform(0, add_spread)
-
-    If `max_sleep` is provided, the duration will be capped at that value.
+    Sleep for a random duration by combining multiplicative and additive jitter.
 
     :param base: Base sleep time in seconds. Must be >= 0.
     :param add_spread: Maximum extra seconds to add after scaling base.
     :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 < 1.0:
-        logger.warning(
-            "[async sleep] Invalid parameters: base=%s, add_spread=%s, mul_spread=%s",
-            base,
-            add_spread,
-            mul_spread,
-        )
+    duration = _calc_sleep_duration(
+        base,
+        add_spread,
+        mul_spread,
+        max_sleep,
+        log_prefix="sleep",
+    )
+    if duration is None:
         return
+    time.sleep(duration)
 
-    multiplicative_jitter = random.uniform(1.0, mul_spread)
-    additive_jitter = random.uniform(0, add_spread)
-    duration = base * multiplicative_jitter + additive_jitter
 
-    if max_sleep is not None:
-        duration = min(duration, max_sleep)
+async def async_jitter_sleep(
+    base: float,
+    add_spread: float = 0.0,
+    mul_spread: float = 1.0,
+    *,
+    max_sleep: float | None = None,
+) -> None:
+    """
+    Async sleep for a random duration by combining multiplicative and additive jitter.
 
-    logger.debug("[async time] Sleeping for %.2f seconds", duration)
+    :param base: Base sleep time in seconds. Must be >= 0.
+    :param add_spread: Maximum extra seconds to add after scaling base.
+    :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.
+    """
+    duration = _calc_sleep_duration(
+        base, add_spread, mul_spread, max_sleep, log_prefix="async sleep"
+    )
+    if duration is None:
+        return
     await asyncio.sleep(duration)

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"
+        )