donghua-cli 3.1.0__py3-none-any.whl

donghua_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Donghua CLI - Wuxia-themed terminal client for streaming Chinese animation."""
+
+__version__ = "3.1.0"

donghua_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m donghua_cli`."""
+
+from donghua_cli.cli import main
+
+main()

donghua_cli/app.py

@@ -0,0 +1,325 @@
+"""Main application logic.
+
+Wires together sources, extractor (with server fallback), player, cache, and UI.
+The user never picks a source -- search is global, sources become servers.
+"""
+
+import threading
+import time
+from typing import List
+
+from donghua_cli import config, theme, ui
+from donghua_cli.cache import Preloader, StreamCache
+from donghua_cli.extractor import extract_with_fallback
+from donghua_cli.player import Downloader, Player
+from donghua_cli.scraper import get_episodes, search_all, _is_movie
+from donghua_cli.sources import ALL_SOURCES, get_source
+from donghua_cli.sources.base import Episode, Series
+
+console = theme.console
+
+
+class DonghuaCLI:
+    def __init__(self, quality: str | None = None):
+        config.ensure_dirs()
+        self._cache = StreamCache()
+        self._preloader = Preloader(self._cache)
+        self._player: Player | None = None
+        self._quality = quality or config.get_quality()
+
+    # ── public entry points ──────────────────────────────────────────────
+
+    def run_interactive(self) -> None:
+        """Fully interactive loop: search -> select -> play/download -> repeat."""
+        try:
+            while True:
+                ui.show_banner()
+
+                query = ui.get_search_query()
+                if not query:
+                    theme.status("warning", "Please enter a search term")
+                    time.sleep(1)
+                    continue
+
+                series_list = self._search(query)
+                if not series_list:
+                    console.print(theme.tip_box("No Results", "Try a different search term", "gold"))
+                    time.sleep(3)
+                    continue
+
+                series = self._pick_series(series_list)
+                episodes = self._get_episodes(series)
+                if not episodes:
+                    console.print(theme.tip_box("No Episodes", "This series has no episodes yet", "gold"))
+                    time.sleep(3)
+                    continue
+
+                selected = ui.select_episodes_from_list(episodes)
+                method = ui.choose_method()
+
+                if method == "download":
+                    self._download_episodes(selected, series.title)
+                else:
+                    self._play_episodes(selected, series.title)
+
+                if not ui.ask_continue():
+                    theme.farewell()
+                    break
+
+        except KeyboardInterrupt:
+            self._cleanup()
+            theme.divider()
+            theme.status("info", "Cultivation session interrupted")
+            theme.status("success", "May your journey be eternal")
+
+    def run_direct(self, query: str, download: bool = False) -> None:
+        """CLI mode with arguments."""
+        ui.show_banner()
+
+        series_list = self._search(query)
+        if not series_list:
+            console.print(theme.tip_box("No Results", "Try a different search term", "gold"))
+            return
+
+        series = self._pick_series(series_list)
+        episodes = self._get_episodes(series)
+        if not episodes:
+            console.print(theme.tip_box("No Episodes", "This series has no episodes yet", "gold"))
+            return
+
+        selected = ui.select_episodes_from_list(episodes)
+
+        if download:
+            self._download_episodes(selected, series.title)
+        else:
+            self._play_episodes(selected, series.title)
+
+    def clear_cache(self) -> None:
+        ui.show_banner()
+        theme.status("loading", "Clearing stream cache...")
+        if self._cache.clear():
+            theme.status("success", "Cache cleared")
+        else:
+            theme.status("info", "No cache to clear")
+
+    def show_features(self) -> None:
+        ui.show_banner()
+        theme.section_header("Core Abilities", "Features & Capabilities", "Everything you need to stream Donghua")
+        theme.feature_cards()
+        console.print()
+        source_names = ", ".join(s.name for s in ALL_SOURCES)
+        console.print(f"  [steel]Active servers:[/] [gold]{source_names}[/]")
+        console.print()
+        console.print(theme.tip_box("Quick Start", "Run 'dhua' for interactive mode or 'dhua --help' for all options"))
+        console.print()
+
+    # ── internal ─────────────────────────────────────────────────────────
+
+    def _search(self, query: str) -> List[Series]:
+        theme.divider()
+        from donghua_cli.scraper import _SEARCH_SKIP
+        search_sources = [s for s in ALL_SOURCES if s.key not in _SEARCH_SKIP]
+        source_names = " + ".join(s.name for s in search_sources)
+
+        from rich.live import Live
+        from rich.spinner import Spinner
+
+        with Live(
+            Spinner("dots", text=f"[gold]Searching '{query}' across {source_names}...[/]"),
+            console=console,
+            transient=True,
+        ):
+            results = search_all(query)
+
+        if results:
+            theme.status("success", f"Found {len(results)} result(s)")
+            # Show how many sources each result is on
+            multi = sum(1 for s in results if len(s.sources) > 1)
+            if multi:
+                theme.status("info", f"{multi} available on multiple servers")
+        else:
+            theme.status("error", "No results found")
+        return results
+
+    def _pick_series(self, series_list: List[Series]) -> Series:
+        """Let user pick a series from unified results."""
+        # Build display list with server badges and movie/series type tags
+        display_items: list[tuple[str, str]] = []
+        for s in series_list:
+            type_tag = "[MOVIE]" if _is_movie(s.title) else "[SERIES]"
+            badges = " ".join(f"[{k.upper()}]" for k in s.sources)
+            display_items.append((s.title, f"{type_tag} {badges}"))
+
+        idx = ui.select_from_list_with_badges(display_items, "CULTIVATION MANUALS")
+        return series_list[idx]
+
+    def _get_episodes(self, series: Series) -> List[Episode]:
+        theme.divider()
+
+        from rich.live import Live
+        from rich.spinner import Spinner
+
+        with Live(
+            Spinner("dots", text="[gold]Fetching episodes from all servers...[/]"),
+            console=console,
+            transient=True,
+        ):
+            episodes = get_episodes(series)
+
+        if episodes:
+            multi = sum(1 for e in episodes if len(e.sources) > 1)
+            theme.status("success", f"Found {len(episodes)} episode(s)")
+            if multi:
+                theme.status("info", f"{multi} episodes have multiple servers (auto-fallback enabled)")
+        else:
+            theme.status("warning", "No episodes found")
+        return episodes
+
+    def _play_episodes(self, episodes: List[Episode], series_title: str) -> None:
+        self._player = Player(self._quality)
+        theme.divider()
+        theme.status("loading", "Preparing playback...")
+
+        idx = 0
+        while idx < len(episodes):
+            ep = episodes[idx]
+
+            ui.clear_screen()
+            ui.show_banner()
+
+            # Resolve stream with automatic server fallback
+            from rich.live import Live
+            from rich.spinner import Spinner
+
+            with Live(
+                Spinner("dots", text="[gold]Resolving stream...[/]"),
+                console=console,
+                transient=True,
+            ):
+                stream_url, source_key = self._preloader.get_stream(ep, extract_with_fallback)
+            source = get_source(source_key)
+            server_name = source.name if source else source_key.upper()
+
+            # Start preloading next episodes
+            self._preloader.preload(episodes, idx, extract_with_fallback)
+
+            ui.show_playback(ep.title, idx + 1, len(episodes), server_name, ep.sources)
+
+            if not self._player.play(stream_url, title=f"{series_title} - {ep.title}"):
+                theme.status("error", "No player found -- install mpv or vlc")
+                console.print(f"  [steel]Stream URL:[/] {stream_url}")
+                return
+
+            theme.status("success", f"Player launched! Server: {server_name}")
+
+            # Monitor player in background
+            finished = threading.Event()
+
+            def _monitor():
+                while self._player and self._player.is_playing():
+                    time.sleep(0.5)
+                finished.set()
+                theme.status("success", "Episode finished! Press Enter or type a command.")
+
+            threading.Thread(target=_monitor, daemon=True).start()
+
+            # Command loop
+            action = None
+            while action is None:
+                try:
+                    cmd = console.input(theme.prompt_text("Command [N/P/S/R/D/Q]")).strip().lower()
+                except KeyboardInterrupt:
+                    self._player.stop()
+                    theme.divider()
+                    theme.status("info", "Session ended")
+                    return
+
+                if cmd in ("n", ""):
+                    if idx < len(episodes) - 1:
+                        action = "next"
+                    elif finished.is_set():
+                        action = "done"
+                    else:
+                        theme.status("warning", "Already at last episode")
+                elif cmd == "p":
+                    if idx > 0:
+                        action = "prev"
+                    else:
+                        theme.status("warning", "Already at first episode")
+                elif cmd == "r":
+                    action = "replay"
+                elif cmd == "s":
+                    try:
+                        n = int(console.input(theme.prompt_text(f"Skip to [1-{len(episodes)}]")).strip())
+                        if 1 <= n <= len(episodes):
+                            action = ("skip", n - 1)
+                        else:
+                            theme.status("error", f"Out of range (1-{len(episodes)})")
+                    except (ValueError, KeyboardInterrupt):
+                        pass
+                elif cmd == "d":
+                    theme.status("loading", "Downloading...")
+                    Downloader.download(stream_url, series_title, ep.title, self._quality)
+                elif cmd == "q":
+                    action = "quit"
+                else:
+                    console.print("  [steel]Commands:[/] [light.gold]\\[N]ext \\[P]rev \\[S]kip \\[R]eplay \\[D]ownload \\[Q]uit[/]")
+
+            self._player.stop()
+
+            old_idx = idx
+            if action == "next":
+                idx += 1
+            elif action == "prev":
+                idx -= 1
+            elif action == "replay":
+                pass
+            elif action == "quit":
+                break
+            elif action == "done":
+                idx += 1
+            elif isinstance(action, tuple) and action[0] == "skip":
+                idx = action[1]
+
+            if action != "quit":
+                self._preloader.record_navigation(old_idx, idx)
+
+        theme.divider()
+        theme.status("success", "All techniques mastered!")
+
+    def _download_episodes(self, episodes: List[Episode], series_title: str) -> None:
+        theme.divider()
+        theme.section_header(
+            "Archive Mode",
+            "Downloading Episodes",
+            f"Saving {len(episodes)} episode(s) to {config.get_download_dir()}",
+        )
+
+        ok = 0
+        fail = 0
+
+        for i, ep in enumerate(episodes, 1):
+            display_num = ep.number if ep.number < 999999 else i
+            console.print(f"\n  [gold]\\[{i:03d}/{len(episodes):03d}][/] Episode {display_num:03d} -- [white]{ep.title[:55]}[/]")
+
+            stream_url, source_key = self._preloader.get_stream(ep, extract_with_fallback)
+            source = get_source(source_key)
+            theme.status("loading", f"Downloading from {source.name if source else source_key}...")
+
+            if Downloader.download(stream_url, series_title, ep.title, self._quality):
+                theme.status("success", "Done")
+                ok += 1
+            else:
+                theme.status("error", "Failed")
+                fail += 1
+
+        theme.divider()
+        theme.status("success", f"{ok}/{len(episodes)} episodes downloaded")
+        if fail:
+            theme.status("error", f"{fail} failed")
+        theme.status("info", f"Saved to: {config.get_download_dir()}")
+
+    def _cleanup(self) -> None:
+        self._preloader.stop()
+        if self._player:
+            self._player.stop()

donghua_cli/cache.py

@@ -0,0 +1,167 @@
+"""LRU stream cache and adaptive background preloader.
+
+The cache persists stream URLs to disk so repeat plays are instant.
+The preloader tracks navigation patterns and adapts:
+  - Sequential watching: preload 3-5 episodes ahead
+  - Random jumping: reduce to 1-2 or stop entirely
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from collections import OrderedDict
+from typing import TYPE_CHECKING, List, Optional
+
+from donghua_cli import config
+
+if TYPE_CHECKING:
+    from donghua_cli.sources.base import Episode
+
+
+class StreamCache:
+    """Persistent LRU cache for resolved stream URLs."""
+
+    def __init__(self, max_size: int = 100):
+        self.max_size = max_size
+        self._cache: OrderedDict[str, tuple[str, str]] = OrderedDict()  # ep_key -> (stream_url, source_key)
+        self._load()
+
+    def _key(self, episode: Episode) -> str:
+        """Cache key from episode's primary URL."""
+        return episode.primary_url
+
+    def get(self, key: str) -> Optional[tuple[str, str]]:
+        """Get cached (stream_url, source_key) or None."""
+        if key in self._cache:
+            self._cache.move_to_end(key)
+            return self._cache[key]
+        return None
+
+    def put(self, key: str, stream_url: str, source_key: str) -> None:
+        if key in self._cache:
+            self._cache.move_to_end(key)
+        else:
+            if len(self._cache) >= self.max_size:
+                self._cache.popitem(last=False)
+        self._cache[key] = (stream_url, source_key)
+        self._save()
+
+    def clear(self) -> bool:
+        self._cache.clear()
+        try:
+            if os.path.exists(config.STREAM_CACHE_FILE):
+                os.remove(config.STREAM_CACHE_FILE)
+                return True
+        except OSError:
+            pass
+        return False
+
+    def _save(self) -> None:
+        try:
+            os.makedirs(config.CACHE_DIR, exist_ok=True)
+            # Serialize as list of [key, [stream_url, source_key]]
+            data = [[k, list(v)] for k, v in self._cache.items()]
+            with open(config.STREAM_CACHE_FILE, "w") as f:
+                json.dump(data, f)
+        except OSError:
+            pass
+
+    def _load(self) -> None:
+        try:
+            if os.path.exists(config.STREAM_CACHE_FILE):
+                with open(config.STREAM_CACHE_FILE, "r") as f:
+                    items = json.load(f)
+                    self._cache = OrderedDict()
+                    for item in items[-self.max_size:]:
+                        key = item[0]
+                        val = item[1]
+                        # Handle old format (string) and new format ([url, source])
+                        if isinstance(val, str):
+                            self._cache[key] = (val, "unknown")
+                        elif isinstance(val, list) and len(val) == 2:
+                            self._cache[key] = (val[0], val[1])
+        except (OSError, json.JSONDecodeError, (IndexError, KeyError)):
+            self._cache = OrderedDict()
+
+
+class Preloader:
+    """Adaptive background preloader that adjusts lookahead based on watch pattern."""
+
+    MIN_LOOKAHEAD = 1
+    MAX_LOOKAHEAD = 5
+    HISTORY_SIZE = 6
+
+    def __init__(self, cache: StreamCache):
+        self.cache = cache
+        self._thread: Optional[threading.Thread] = None
+        self._stop = threading.Event()
+        self._nav_history: list[int] = []
+        self._lookahead = 2
+
+    def record_navigation(self, prev_idx: int, new_idx: int) -> None:
+        """Record a navigation action to adapt preloading depth."""
+        delta = new_idx - prev_idx
+        self._nav_history.append(delta)
+        if len(self._nav_history) > self.HISTORY_SIZE:
+            self._nav_history = self._nav_history[-self.HISTORY_SIZE:]
+
+        if len(self._nav_history) >= 3:
+            sequential = sum(1 for d in self._nav_history if d == 1)
+            ratio = sequential / len(self._nav_history)
+
+            if ratio >= 0.8:
+                self._lookahead = min(self._lookahead + 1, self.MAX_LOOKAHEAD)
+            elif ratio >= 0.5:
+                self._lookahead = max(2, self._lookahead)
+            else:
+                self._lookahead = max(self.MIN_LOOKAHEAD, self._lookahead - 1)
+
+    @property
+    def lookahead(self) -> int:
+        return self._lookahead
+
+    def preload(self, episodes: List[Episode], current_idx: int, extract_fn) -> None:
+        """Start preloading upcoming episodes in a daemon thread."""
+        self.stop()
+        self._stop.clear()
+
+        end = min(current_idx + 1 + self._lookahead, len(episodes))
+        upcoming = episodes[current_idx + 1 : end]
+        if not upcoming:
+            return
+
+        def _worker():
+            for ep in upcoming:
+                if self._stop.is_set():
+                    break
+                key = ep.primary_url
+                if self.cache.get(key):
+                    continue
+                try:
+                    stream_url, source_key = extract_fn(ep)
+                    if stream_url and stream_url != ep.primary_url:
+                        self.cache.put(key, stream_url, source_key)
+                except Exception:
+                    pass
+
+        self._thread = threading.Thread(target=_worker, daemon=True)
+        self._thread.start()
+
+    def get_stream(self, episode: Episode, extract_fn) -> tuple[str, str]:
+        """Return (stream_url, source_key) -- cached or freshly extracted."""
+        key = episode.primary_url
+        cached = self.cache.get(key)
+        if cached:
+            return cached
+        stream_url, source_key = extract_fn(episode)
+        if stream_url:
+            self.cache.put(key, stream_url, source_key)
+        return stream_url, source_key
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1)
+        self._thread = None

donghua_cli/cli.py

@@ -0,0 +1,131 @@
+"""CLI entry point -- argument parsing and dispatch."""
+
+import logging
+import sys
+
+from donghua_cli import __version__, config
+
+
+def _setup_logging(log_file: str | None = None, verbose: bool = False) -> None:
+    """Configure the donghua logger.
+
+    --logs:    writes to ~/.cache/donghua/donghua.log and tails it
+    --verbose: prints debug output to stderr
+    """
+    logger = logging.getLogger("donghua")
+    logger.setLevel(logging.DEBUG)
+    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S")
+
+    if log_file:
+        import os
+        os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        fh = logging.FileHandler(log_file, mode="w")
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(fmt)
+        logger.addHandler(fh)
+
+    if verbose:
+        sh = logging.StreamHandler(sys.stderr)
+        sh.setLevel(logging.DEBUG)
+        sh.setFormatter(fmt)
+        logger.addHandler(sh)
+
+
+def main() -> None:
+    if config.PLATFORM == "windows":
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+        except Exception:
+            pass
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="donghua",
+        description="Donghua CLI -- Wuxia-themed terminal streaming client",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""\
+Examples:
+  donghua                          Interactive TUI mode
+  donghua "soul land"              Search and stream
+  donghua "btth" -q 1080           Stream at 1080p
+  donghua "martial peak" -d        Download mode
+  donghua --classic                Classic Rich output mode
+  donghua --logs                   Show live debug log in a second terminal
+  dhua                             Interactive TUI (alias)
+""",
+    )
+
+    parser.add_argument("query", nargs="?", help="Series to search for")
+    parser.add_argument("-q", "--quality", default=None, help=f"Video quality (default: {config.get_quality()})")
+    parser.add_argument("-d", "--download", action="store_true", help="Download instead of stream")
+    parser.add_argument("--classic", action="store_true", help="Use classic Rich output instead of TUI")
+    parser.add_argument("--logs", action="store_true", help="Write debug log to file and show path")
+    parser.add_argument("--verbose", action="store_true", help="Print debug output to stderr")
+    parser.add_argument("--clear-cache", action="store_true", help="Clear the stream cache")
+    parser.add_argument("--features", action="store_true", help="Show features and capabilities")
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+
+    args = parser.parse_args()
+
+    # Set up logging
+    import os
+    log_file = None
+    if args.logs:
+        log_file = os.path.join(config.CACHE_DIR, "donghua.log")
+        _setup_logging(log_file=log_file, verbose=False)
+        print(f"Logging to: {log_file}")
+        print(f"Watch live:  tail -f {log_file}")
+        print()
+    elif args.verbose:
+        _setup_logging(verbose=True)
+    else:
+        # Silence logs by default
+        logging.getLogger("donghua").addHandler(logging.NullHandler())
+
+    from donghua_cli.app import DonghuaCLI
+    app_core = DonghuaCLI(quality=args.quality)
+
+    if args.features:
+        app_core.show_features()
+        return
+
+    if args.clear_cache:
+        app_core.clear_cache()
+        if not args.query:
+            return
+
+    # Classic mode or direct query: use Rich console output
+    if args.classic or args.query or args.download:
+        try:
+            if args.query:
+                app_core.run_direct(args.query, download=args.download)
+            else:
+                app_core.run_interactive()
+        except KeyboardInterrupt:
+            from donghua_cli import theme
+            theme.divider()
+            theme.status("info", "Farewell, cultivator!")
+            sys.exit(0)
+        except Exception as e:
+            from donghua_cli import theme
+            theme.status("error", f"Fatal: {e}")
+            sys.exit(1)
+        return
+
+    # Default: Textual TUI mode
+    try:
+        from donghua_cli.tui import DonghuaTUI
+        tui = DonghuaTUI(app_core)
+        tui.run()
+    except ImportError:
+        try:
+            app_core.run_interactive()
+        except KeyboardInterrupt:
+            sys.exit(0)
+    except Exception as e:
+        from donghua_cli import theme
+        theme.status("error", f"TUI error: {e}")
+        sys.exit(1)