anime-sama-cli-api 0.4.0__py3-none-any.whl

anime_sama_api/cli/downloader.py

@@ -0,0 +1,323 @@
+import asyncio
+import logging
+import random
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
+from pathlib import Path
+from typing import cast
+from urllib.parse import urlparse
+
+from rich import get_console
+from rich.console import Group
+from rich.live import Live
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    ProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+    TotalFileSizeColumn,
+    TransferSpeedColumn,
+)
+from rich.table import Column
+from yt_dlp import YoutubeDL
+from yt_dlp.utils import DownloadError
+
+from anime_sama_api.cli.config import PlayersConfig, config
+from anime_sama_api.cli.error_handling import YDL_log_filter, reaction_to
+from anime_sama_api.episode import (
+    DeferredPlayers,
+    Episode,
+    iter_resolved_players,
+    resolve_reference,
+)
+from anime_sama_api.langs import Lang
+
+from ..link_resolver import RateLimitedError
+
+logger = logging.getLogger(__name__)
+logger.addFilter(YDL_log_filter)
+console = get_console()
+download_progress_list: list[str | ProgressColumn] = [
+    "[bold blue]{task.fields[episode_name]}",
+    BarColumn(bar_width=None),
+    "[progress.percentage]{task.percentage:>3.1f}%",
+    TransferSpeedColumn(),
+    TotalFileSizeColumn(),
+    TimeRemainingColumn(compact=True, elapsed_when_finished=True),
+]
+if config.show_players:
+    download_progress_list.insert(
+        1,
+        TextColumn(
+            "[green]{task.fields[site]}",
+            table_column=Column(max_width=12),
+            justify="right",
+        ),
+    )
+download_progress = Progress(*download_progress_list, console=console)
+total_progress = Progress(
+    TextColumn("[bold cyan]{task.description}"),
+    BarColumn(bar_width=None),
+    MofNCompleteColumn(),
+    TimeRemainingColumn(elapsed_when_finished=True),
+    console=console,
+)
+progress = Group(total_progress, download_progress)
+
+
+def download(
+    episode: Episode,
+    path: Path,
+    episode_path: str = "{episode}",
+    prefer_languages: list[Lang] | None = None,
+    players_config: PlayersConfig | None = None,
+    concurrent_fragment_downloads: int = 3,
+    max_retry_time: int = 1024,
+    video_format: str = "",
+    format_sort: str = "",
+    ep_year: int | None = None,
+    *,
+    _total_task_id=None,
+) -> bool:
+    if prefer_languages is None:
+        prefer_languages = ["VOSTFR"]
+    if players_config is None:
+        players_config = PlayersConfig([], [])
+    if not any(episode.languages.values()):
+        logger.error("No player available")
+        if _total_task_id is not None:
+            total_progress.update(_total_task_id, advance=1)
+        return False
+    me = download_progress.add_task(
+        "download", episode_name=episode.name, site="", total=None
+    )
+    task = next(t for t in download_progress.tasks if t.id == me)
+    try:
+        full_path = (
+            path
+            / episode_path.format(
+                series=episode.series_name,
+                season=episode.season_name,
+                episode=episode.name,
+                release_year_parentheses="" if ep_year is None else f" {ep_year}",
+            )
+        ).expanduser()
+
+        def hook(data: dict) -> None:
+            if data.get("status") != "downloading":
+                return
+            task.total = data.get("total_bytes") or data.get("total_bytes_estimate")
+            download_progress.start_task(me)
+            download_progress.update(me, completed=data.get("downloaded_bytes", 0))
+
+        option = {
+            "outtmpl": f"{full_path}.%(ext)s",
+            "concurrent_fragment_downloads": concurrent_fragment_downloads,
+            "progress_hooks": [hook],
+            "logger": logger,
+            "format": video_format,
+            "format_sort": format_sort.split(","),
+            "continuedl": False,
+        }
+        success = False
+        for player in episode.consume_player(
+            prefer_languages, players_config.prefers, players_config.bans
+        ):
+            download_progress.reset(
+                me,
+                start=False,
+                completed=0,
+                episode_name=episode.name,
+                site=urlparse(player).hostname,
+            )
+            task.total = None
+            retry_time = 1
+            success = False
+            download_progress.update(me, site=urlparse(player).hostname)
+            while True:
+                try:
+                    with YoutubeDL(option) as ydl:
+                        error_code = cast(int, ydl.download([player]))
+                        if not error_code:
+                            success = True
+                        else:
+                            logger.fatal(
+                                "The download encountered an error code %s. Please report this to the developer with URL: %s",
+                                error_code,
+                                player,
+                            )
+                        break
+                except DownloadError as exception:
+                    match reaction_to(exception.msg):
+                        case "continue":
+                            break
+                        case "retry":
+                            if retry_time >= max_retry_time:
+                                break
+                            logger.warning(
+                                "%s interrupted (%s). Retrying in %ss.",
+                                episode.name,
+                                exception.msg,
+                                retry_time,
+                            )
+                            time.sleep(retry_time * random.uniform(0.8, 1.2))
+                            retry_time *= 2
+                        case "crash":
+                            raise
+                        case "":
+                            logger.fatal(
+                                "The above error wasn't handle. Please report it to the developer with URL: %s",
+                                player,
+                            )
+                            break
+            if success:
+                break
+        return success
+    finally:
+        download_progress.update(me, visible=False)
+        if _total_task_id is not None:
+            total_progress.update(_total_task_id, advance=1)
+
+
+def multi_download(
+    episodes,
+    path,
+    episode_path="{episode}",
+    concurrent_downloads=None,
+    prefer_languages=None,
+    players_config=None,
+    max_retry_time=1024,
+    video_format="",
+    format_sort="",
+    eps_years=None,
+) -> list[bool]:
+    if not episodes:
+        return []
+    concurrent_downloads = concurrent_downloads or {}
+    if prefer_languages is None:
+        prefer_languages = ["VOSTFR"]
+    if players_config is None:
+        players_config = PlayersConfig([], [])
+    years = list(eps_years or [])
+    years += [None] * max(0, len(episodes) - len(years))
+    batch = total_progress.add_task("Épisodes traités", total=len(episodes))
+    with (
+        Live(progress, console=console),
+        ThreadPoolExecutor(
+            max_workers=max(1, concurrent_downloads.get("video", 1))
+        ) as executor,
+    ):
+        futures = [
+            executor.submit(
+                download,
+                episode,
+                path,
+                episode_path,
+                prefer_languages,
+                players_config,
+                concurrent_downloads.get("fragment", 1),
+                max_retry_time,
+                video_format,
+                format_sort,
+                ep_year=year,
+                _total_task_id=batch,
+            )
+            for episode, year in zip(episodes, years)
+        ]
+        return [future.result() for future in futures]
+
+
+class LazyEpisode:
+    def __init__(self, episode, loop, resolve, stopped):
+        self._episode = episode
+        self._loop = loop
+        self._resolve = resolve
+        self._stopped = stopped
+        self.streams = []
+
+    def __getattr__(self, name):
+        return getattr(self._episode, name)
+
+    def consume_player(self, prefer_languages, prefer_players=None, ban_players=None):
+        stream = iter_resolved_players(
+            self._episode, prefer_languages, ban_players or (), self._resolve
+        )
+        self.streams.append(stream)
+
+        async def next_url():
+            if self._stopped.is_set():
+                raise StopAsyncIteration
+            return await anext(stream)
+
+        while not self._stopped.is_set():
+            future = asyncio.run_coroutine_threadsafe(next_url(), self._loop)
+            try:
+                url = future.result()
+            except StopAsyncIteration:
+                return
+            except RateLimitedError:
+                self._stopped.set()
+                raise
+            if self._stopped.is_set():
+                return
+            yield url
+
+
+async def download_episodes(episodes, config, year=None):
+    episodes = list(episodes)
+    if not episodes:
+        return True
+    loop = asyncio.get_running_loop()
+    stopped = threading.Event()
+    api_slots = asyncio.Semaphore(3)
+    locks = {}
+
+    async def resolve(players, reference):
+        async with api_slots:
+            if stopped.is_set():
+                return ""
+            if not isinstance(players, DeferredPlayers):
+                return await resolve_reference(players, reference)
+            lock = locks.setdefault(id(players.resolver), asyncio.Lock())
+            async with lock:
+                if stopped.is_set():
+                    return ""
+                try:
+                    return await resolve_reference(players, reference)
+                except RateLimitedError:
+                    stopped.set()
+                    raise
+
+    proxies = [LazyEpisode(ep, loop, resolve, stopped) for ep in episodes]
+
+    def run():
+        return multi_download(
+            proxies,
+            config.download_path,
+            config.episode_path,
+            config.concurrent_downloads,
+            config.prefer_languages,
+            config.players_config,
+            config.max_retry_time,
+            config.format,
+            config.format_sort,
+            [year] * len(proxies),
+        )
+
+    worker = asyncio.create_task(asyncio.to_thread(run))
+    try:
+        results = await asyncio.shield(worker)
+        return all(results)
+    except asyncio.CancelledError:
+        stopped.set()
+        with suppress(Exception):
+            await asyncio.shield(worker)
+        raise
+    finally:
+        for proxy in proxies:
+            for stream in proxy.streams:
+                await stream.aclose()

anime_sama_api/cli/error_handling.py

@@ -0,0 +1,66 @@
+from collections.abc import Sequence
+from logging import LogRecord
+from typing import Literal
+
+Reaction = Literal["continue", "retry", "crash", ""]
+
+how_to_react: dict[Reaction, Sequence[str]] = {
+    "continue": (
+        "[Errno 61] Connection refused",
+        "Remote end closed connection without response",
+        "HTTPError 404: Not Found",
+        "Unsupported URL",
+        "[Errno 7] No address associated with hostname",
+        "[Errno 11002] getaddrinfo failed",
+    ),
+    "retry": (
+        "Unable to download webpage: HTTP Error 522",
+        "unable to download video data: HTTP Error 416",
+        "HTTPError 500: Internal Server Error",
+        "The read operation timed out",
+        "Waiting for vidmoly",  # Custom error msg to tell the downloader to retry
+        "TransportError('timed out')",
+        "[Errno 54] Connection reset by peer",
+        "[Errno 104] Connection reset by peer",
+        "HTTPError 503: Service Temporarily Unavailable",
+        "[Errno 32] Broken pipe",
+        "[Errno 101] Network is unreachable",
+        "[Errno 51] Network is unreachable",
+        "[Errno 2] No such file or directory",
+    ),
+    "crash": (),
+}
+
+
+def reaction_to(msg: str | None) -> Reaction:
+    if msg is None:
+        return "continue"
+
+    for reaction, error_msgs in how_to_react.items():
+        for error_msg in error_msgs:
+            if error_msg in msg:
+                return reaction
+    return ""
+
+
+def is_error_handle(msg: str) -> bool:
+    return bool(reaction_to(msg))
+
+
+def YDL_log_filter(record: LogRecord) -> bool:
+    if record.filename != "YoutubeDL.py":
+        return True
+
+    match record.levelname:
+        case "WARNING":
+            return all(
+                msg not in record.msg
+                for msg in (
+                    "Falling back on generic information extractor",
+                    "Live HLS streams are not supported by the native downloader.",
+                )
+            )
+        case "ERROR":
+            return not is_error_handle(record.msg)
+        case _:
+            return True

anime_sama_api/cli/internal_player.py

@@ -0,0 +1,56 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from rich import print
+
+from anime_sama_api.cli.config import config
+from anime_sama_api.episode import Episode
+from anime_sama_api.langs import Lang
+
+
+def open_silent_process(command: list[str]) -> subprocess.Popen[bytes]:
+    try:
+        if os.name in ("nt", "dos"):
+            return subprocess.Popen(command)
+        else:
+            return subprocess.Popen(
+                command, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
+            )
+
+    except FileNotFoundError as e:
+        print(f"[red]Error: {e}")
+        sys.exit(404)
+
+
+def play_episode(
+    episode: Episode,
+    prefer_languages: list[Lang],
+    args: list[str] | None = None,
+) -> subprocess.Popen[bytes] | None:
+    best = episode.best(prefer_languages)
+    if best is None:
+        print("[red]No player available")
+        return None
+
+    player_command = config.internal_player_command + [best]
+    if args is not None:
+        player_command += args
+
+    # Check by the caller
+    # if isinstance(self._sub_proc, sp.Popen):
+    #     self.kill_player()
+
+    return open_silent_process(player_command)
+
+    # self._write_hist(entry)
+    # self._start_dc_presence(entry)
+
+
+def play_file(path: Path, args: list[str] | None = None) -> subprocess.Popen[bytes]:
+    player_command = config.internal_player_command + [str(path)]
+    if args is not None:
+        player_command += args
+
+    return open_silent_process(player_command)

anime_sama_api/cli/play_menu.py

@@ -0,0 +1,61 @@
+import asyncio
+
+from anime_sama_api.episode import Episode, iter_resolved_players
+
+from .config import config
+
+
+class EpisodesManager:
+    def __init__(self, episodes: list[Episode], current_index: int = 0) -> None:
+        self.episodes = episodes
+        self.current_index = current_index
+
+    def __next__(self) -> Episode:
+        if self.current_index < len(self.episodes) - 1:
+            self.current_index += 1
+            return self.episodes[self.current_index]
+
+        raise StopIteration
+
+    def previous(self) -> Episode:
+        if self.current_index > 0:
+            self.current_index -= 1
+            return self.episodes[self.current_index]
+
+        raise StopIteration
+
+    @property
+    def current(self) -> Episode:
+        return self.episodes[self.current_index]
+
+
+class PlayMenu:
+    def print_menu(self) -> None:
+        pass
+
+
+async def play_episode(episode):
+    from . import internal_player
+
+    async for url in iter_resolved_players(
+        episode, config.prefer_languages, config.players_config.bans
+    ):
+
+        class PlayerEpisode:
+            def __getattr__(self, name):
+                return getattr(episode, name)
+
+            def best(self, prefer_languages, url=url):
+                return url
+
+            def consume_player(self, *args, url=url, **kwargs):
+                yield url
+
+        command = internal_player.play_episode(PlayerEpisode(), config.prefer_languages)
+        if command is not None and await asyncio.to_thread(command.wait) == 0:
+            return True
+    return False
+
+
+async def async_main(episodes: list[Episode]):
+    return await play_episode(episodes[0])

anime_sama_api/cli/utils.py

@@ -0,0 +1,142 @@
+import ctypes
+import os
+import re
+import sys
+from collections.abc import Callable
+from ctypes import wintypes
+from typing import Any, TypeVar
+
+from rich import print as print_func
+
+input_func = input
+T = TypeVar("T")
+
+
+def safe_input(
+    text: str,
+    transform: Callable[[str], T],
+    exceptions: tuple[type[Exception], ...] = (ValueError, IndexError),
+) -> T:
+    while True:
+        try:
+            print_func(text, end="")
+            output = input_func()
+            return transform(output)
+        except exceptions:
+            pass
+
+
+def print_selection(
+    choices: list[Any], print_choices: bool = True, exit: bool = True
+) -> None:
+    if len(choices) == 0:
+        print_func("[red]No result")
+        if exit:
+            sys.exit(404)
+        return
+    if len(choices) == 1:
+        print_func(f"-> [blue]{choices[0]}")
+        return
+    if not print_choices:
+        return
+    for index, choice in enumerate(choices, start=1):
+        line_colors = "yellow" if index % 2 == 0 else "white"
+        print_func(
+            f"[green][{index:{len(str(len(choices)))}}]", f"[{line_colors}]{choice}"
+        )
+
+
+def select_one(
+    choices: list[T], msg: str = "Choose a number", **_: dict[Any, Any]
+) -> T:
+    print_selection(choices)
+    if len(choices) == 1:
+        return choices[0]
+    return safe_input(
+        f"[white]{msg}[/white]: \x1b[0;34m", lambda string: choices[int(string) - 1]
+    )
+
+
+def select_range(
+    choices: list[T], msg: str = "Choose a range", print_choices: bool = True
+) -> list[T]:
+    print_selection(choices, print_choices)
+    if len(choices) == 1:
+        return [choices[0]]
+
+    def transform(string: str) -> list[T]:
+        if string in ("*", "all"):
+            return choices
+        ints_set: set[int] = set()
+        for args in string.split(","):
+            ints = [int(num) if num.strip() else None for num in args.split("-")]
+            if len(ints) == 1 and ints[0] is not None:
+                ints_set.add(ints[0])
+            elif len(ints) == 2:
+                if ints[0] is None:
+                    ints[0] = 1
+                if ints[1] is None:
+                    ints[1] = len(choices)
+                ints_set.update(range(ints[0], ints[1] + 1))
+            else:
+                raise ValueError
+        return [choices[i - 1] for i in ints_set]
+
+    return safe_input(
+        f"[white]{msg}[/white] [green][1-{len(choices)}][/]: \x1b[0;34m", transform
+    )
+
+
+def normalize(title: str) -> str:
+    return re.sub("[^\\w\\s]", "", title.lower().strip())
+
+
+ANSI_ESCAPE = re.compile("\\x1b\\[[0-?]*[ -/]*[@-~]")
+
+
+def enable_terminal_colors():
+    """Activer les séquences ANSI sous Windows si possible."""
+    if not sys.stdout.isatty():
+        return False
+    if os.name != "nt":
+        return True
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.GetStdHandle.argtypes = [wintypes.DWORD]
+    kernel32.GetStdHandle.restype = wintypes.HANDLE
+    kernel32.GetConsoleMode.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+    kernel32.GetConsoleMode.restype = wintypes.BOOL
+    kernel32.SetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+    kernel32.SetConsoleMode.restype = wintypes.BOOL
+    stdout_handle = kernel32.GetStdHandle(wintypes.DWORD(-11 & 4294967295))
+    mode = wintypes.DWORD()
+    if not kernel32.GetConsoleMode(stdout_handle, ctypes.byref(mode)):
+        return False
+    return bool(kernel32.SetConsoleMode(stdout_handle, mode.value | 4))
+
+
+def install_clean_prompts():
+    global safe_input, input_func
+    if getattr(safe_input, "_blue_input_fix", False):
+        return
+    original_safe_input = safe_input
+    original_input_func = input_func
+    colors_enabled = enable_terminal_colors()
+
+    def blue_input(*args, **kwargs):
+        if not colors_enabled:
+            return original_input_func(*args, **kwargs)
+        sys.stdout.write("\x1b[0;34m")
+        sys.stdout.flush()
+        try:
+            return original_input_func(*args, **kwargs)
+        finally:
+            sys.stdout.write("\x1b[0m")
+            sys.stdout.flush()
+
+    def clean_safe_input(text, transform, exceptions=(ValueError, IndexError)):
+        clean_text = ANSI_ESCAPE.sub("", text)
+        return original_safe_input(clean_text, transform, exceptions)
+
+    clean_safe_input._blue_input_fix = True
+    input_func = blue_input
+    safe_input = clean_safe_input