anime-sama-api 0.1.0__py3-none-any.whl

anime_sama_api/__init__.py

@@ -0,0 +1,47 @@
+from .top_level import AnimeSama
+from .catalogue import Catalogue
+from .season import Season
+from .episode import Episode, Languages, Players
+from .langs import Lang, LangId, lang2ids, id2lang, lang_ids, flags
+
+try:
+    from .cli.__main__ import main
+    from .cli.downloader import download, multi_download
+except ImportError:
+    import sys
+
+    def main() -> int:
+        print(
+            "This anime-sama_api function could not run because the required "
+            "dependencies were not installed.\nMake sure you've installed "
+            "everything with: pip install 'anime-sama_api[cli]'"
+        )
+
+        sys.exit(1)
+
+    download = multi_download = main  # type: ignore
+
+
+# __package__ = "anime-sama_api"
+__all__ = [
+    "AnimeSama",
+    "Catalogue",
+    "Season",
+    "Players",
+    "Languages",
+    "Episode",
+    "Lang",
+    "LangId",
+    "lang2ids",
+    "id2lang",
+    "lang_ids",
+    "flags",
+    "download",
+    "multi_download",
+    "main",
+]
+
+"""__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "anime-sama_api")  # noqa"""

anime_sama_api/catalogue.py

@@ -0,0 +1,69 @@
+import re
+
+from httpx import AsyncClient
+
+from .season import Season
+
+
+class Catalogue:
+    def __init__(self, url: str, name="", client: AsyncClient | None = None) -> None:
+        self.url = url + "/" if url[-1] != "/" else url
+        self.name = name or url.split("/")[-2]
+        self.site_url = "/".join(url.split("/")[:3]) + "/"
+        self.client = client or AsyncClient()
+        self._page = None
+
+    async def page(self) -> str:
+        if self._page is not None:
+            return self._page
+
+        response = await self.client.get(self.url)
+
+        if not response.is_success:
+            self._page = ""
+        else:
+            self._page = response.text
+
+        return self._page
+
+    async def seasons(self) -> list[Season]:
+        seasons = re.findall(
+            r'panneauAnime\("(.+?)", *"(.+?)(?:vostfr|vf)"\);', await self.page()
+        )
+
+        seasons = [
+            Season(
+                url=self.url + link,
+                name=name,
+                serie_name=self.name,
+                client=self.client,
+            )
+            for name, link in seasons
+        ]
+
+        return seasons
+
+    async def advancement(self) -> str:
+        search = re.findall(r"Avancement.+?>(.+?)<", await self.page())
+
+        if not search:
+            return ""
+
+        return search[0]
+
+    async def correspondance(self):
+        search = re.findall(r"Correspondance.+?>(.+?)<", await self.page())
+
+        if not search:
+            return ""
+
+        return search[0]
+
+    def __repr__(self):
+        return f"Catalogue({self.url!r}, {self.name!r})"
+
+    def __str__(self):
+        return self.name
+
+    def __eq__(self, value):
+        return self.url == value.url

anime_sama_api/cli/__main__.py

@@ -0,0 +1,67 @@
+import asyncio
+import logging
+
+import httpx
+from rich import get_console
+from rich.logging import RichHandler
+
+from . import downloader, internal_player
+from .config import config
+from .utils import safe_input, select_one, select_range
+
+from ..top_level import AnimeSama
+
+console = get_console()
+console._highlight = False
+logging.basicConfig(format="%(message)s", datefmt="[%X]", handlers=[RichHandler()])
+
+
+def spinner(text: str):
+    return console.status(text, spinner_style="cyan")
+
+
+async def async_main():
+    query = safe_input("Anime name: \033[0;34m", str)
+
+    with spinner(f"Searching for [blue]{query}"):
+        catalogues = await AnimeSama(config.url, httpx.AsyncClient()).search(query)
+    catalogue = select_one(catalogues)
+
+    with spinner(f"Getting season list for [blue]{catalogue.name}"):
+        seasons = await catalogue.seasons()
+    season = select_one(seasons)
+
+    with spinner(f"Getting episode list for [blue]{season.name}"):
+        episodes = await season.episodes()
+
+    console.print(f"\n[cyan bold underline]{season.serie_name} - {season.name}")
+    selected_episodes = select_range(
+        episodes, msg="Choose episode(s)", print_choices=True
+    )
+
+    if config.download:
+        downloader.multi_download(
+            selected_episodes,
+            config.download_path,
+            config.concurrent_downloads,
+            config.prefer_languages,
+        )
+    else:
+        command = internal_player.play_episode(
+            selected_episodes[0], config.prefer_languages
+        )
+        if command is not None:
+            command.wait()
+
+
+def main() -> int:
+    try:
+        asyncio.run(async_main())
+    except (KeyboardInterrupt, asyncio.exceptions.CancelledError, EOFError):
+        console.print("\n[red]Exiting...")
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

anime_sama_api/cli/config.py

@@ -0,0 +1,82 @@
+# TODO: Code hard to read / violent error, need refactor
+
+import logging
+from pathlib import Path
+from dataclasses import dataclass
+import os
+import sys
+
+from anime_sama_api.langs import Lang, lang2ids
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PlayersConfig:
+    prefers: list[str]
+    bans: list[str]
+
+
+@dataclass(frozen=True)
+class Config:
+    prefer_languages: list[Lang]
+    download_path: Path
+    download: bool
+    internal_player_command: list[str]
+    url: str
+    players: PlayersConfig
+    concurrent_downloads: dict[str, int]
+
+
+# Load default config
+exemple_config = Path(__file__).parent / "config.toml"
+if not exemple_config.exists():
+    raise FileNotFoundError(
+        "There is an issues with the installation of the package.\nThe exemple config cannot be found."
+    )
+with open(exemple_config, "rb") as file:
+    default_config = tomllib.load(file)
+
+
+# Load user config
+possible_path = ["."]
+possible_path.append(
+    "~/AppData/Local/anime-sama_api" if os.name == "nt" else "~/.config/anime-sama_cli"
+)
+possible_path = [Path(path).expanduser() for path in possible_path]
+
+user_config = {}
+for path in possible_path:
+    config_file = path / "config.toml"
+    if config_file.is_file():
+        with open(config_file, "rb") as config_file:
+            user_config = tomllib.load(config_file)
+            break
+else:
+    from shutil import copy
+
+    possible_path[1].mkdir(parents=True, exist_ok=True)
+    copy(exemple_config, possible_path[1])
+    logger.info("Default config created at %s", possible_path[1])
+
+
+# Update the default values by values set by the user
+config = default_config | user_config
+
+# Check if value respect the type
+for lang in config["prefer_languages"]:
+    assert (
+        lang in lang2ids
+    ), f"{lang} is not a valid languages for prefer_languages\nOnly the following are acceptable: {list(lang2ids.keys())}"
+
+# Convert type
+config["download_path"] = Path(config["download_path"])
+config["internal_player_command"] = config["internal_player_command"].split()
+config["players"] = PlayersConfig(**config["players"])
+config = Config(**config)

anime_sama_api/cli/config.toml

@@ -0,0 +1,26 @@
+# Languages at the start of the list are preferred over the ones that come after
+# Possible values: "VA", "VCN", "VF", "VJ", "VKR", "VQC", "VO"
+prefer_languages = ["VO"]
+
+# Where to put the downloads (an additional folder is created for every series)
+download_path = "~/Downloads/Anime-Sama"
+
+# If it downloads or plays the selected episodes
+download = true
+# What application to use to play
+internal_player_command = "mpv"
+
+# url of anime-sama (You shouldn't touch that)
+url = "https://anime-sama.fr/"
+
+[players]
+# player to use if multiple are available (first in the list are prefer over the afters)
+prefers = []
+# player to not use (even if that the only player)
+bans = []
+
+[concurrent_downloads]
+# how many fragment of a video to download at once
+fragment = 3
+# how many video to download at once
+video = 5

anime_sama_api/cli/downloader.py

@@ -0,0 +1,152 @@
+import time
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from yt_dlp import YoutubeDL, DownloadError
+from rich import print, get_console
+from rich.live import Live
+from rich.console import Group
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+    MofNCompleteColumn,
+    TaskID,
+)
+
+from .error_handeling import YDL_log_filter, reaction_to
+from ..episode import Episode
+from ..langs import Lang
+
+
+logger = logging.getLogger(__name__)
+logger.addFilter(YDL_log_filter)
+
+console = get_console()
+download_progress = Progress(
+    TextColumn("[bold blue]{task.fields[episode_name]}", justify="right"),
+    BarColumn(bar_width=None),
+    "[progress.percentage]{task.percentage:>3.1f}%",
+    "•",
+    DownloadColumn(),
+    "•",
+    TransferSpeedColumn(),
+    "•",
+    TimeRemainingColumn(),
+    console=console,
+)
+total_progress = Progress(
+    TextColumn("[bold cyan]{task.description}"),
+    BarColumn(bar_width=None),
+    MofNCompleteColumn(),
+    TimeRemainingColumn(),
+    console=console,
+)
+progress = Group(total_progress, download_progress)
+
+
+def download(
+    episode: Episode,
+    path: Path,
+    prefer_languages: list[Lang] = ["VO"],
+    concurrent_fragment_downloads=3,
+):
+    if not any(episode.languages.values()):
+        print("[red]No player available")
+        return
+
+    me = download_progress.add_task("download", episode_name=episode.name, total=None)
+    task = download_progress.tasks[me]
+
+    full_path = (
+        path / episode.serie_name / episode.season_name / episode.name
+    ).expanduser()
+
+    def hook(data: dict):
+        if data.get("status") != "downloading":
+            return
+
+        task.total = data.get("total_bytes") or data.get("total_bytes_estimate")
+        download_progress.update(me, completed=data.get("downloaded_bytes", 0))
+
+    option = {
+        "outtmpl": {"default": f"{full_path}.%(ext)s"},
+        "concurrent_fragment_downloads": concurrent_fragment_downloads,
+        "progress_hooks": [hook],
+        "logger": logger,
+    }
+
+    for player in episode.consume_player(prefer_languages):
+        retry_time = 1
+        sucess = False
+
+        while True:
+            try:
+                with YoutubeDL(option) as ydl:  # type: ignore
+                    error_code: int = ydl.download([player])  # type: ignore
+
+                    if not error_code:
+                        sucess = True
+                    else:
+                        logger.fatal(
+                            "The download error with the code %s. Please report this to the developper.",
+                            error_code,
+                        )
+
+                    break
+
+            except DownloadError as execption:
+                match reaction_to(execption.msg):
+                    case "continue":
+                        break
+
+                    case "retry":
+                        logger.warning(
+                            "Download interrupted. Retrying in %ss.", retry_time
+                        )
+                        time.sleep(retry_time)
+                        retry_time *= 2
+
+                    case "crash":
+                        raise execption
+
+                    case "":
+                        logger.fatal(
+                            "The above error wasn't handle. Please report it to the developper."
+                        )
+                        break
+
+        if sucess:
+            break
+
+    download_progress.update(me, visible=False)
+    if total_progress.tasks:
+        total_progress.update(TaskID(0), advance=1)
+
+
+def multi_download(
+    episodes: list[Episode],
+    path: Path,
+    concurrent_downloads={},
+    prefer_languages: list[Lang] = ["VO"],
+):
+    """
+    Not sure if you can use this function multiple times
+    """
+    total_progress.add_task("Downloaded", total=len(episodes))
+    with Live(progress, console=console):
+        with ThreadPoolExecutor(
+            max_workers=concurrent_downloads.get("video", 1)
+        ) as executor:
+            for episode in episodes:
+                executor.submit(
+                    download,
+                    episode,
+                    path,
+                    prefer_languages,
+                    concurrent_downloads.get("fragment", 1),
+                )

anime_sama_api/cli/error_handeling.py

@@ -0,0 +1,42 @@
+from logging import LogRecord
+from typing import Literal
+
+Reaction = Literal["continue", "retry", "crash", ""]
+
+how_to_react: dict[Reaction, tuple[str, ...]] = {
+    "continue": (
+        "[Errno 61] Connection refused",
+        "Remote end closed connection without response",
+        "HTTPError 404: Not Found",
+        "Unsupported URL:",
+        "The read operation timed out",
+    ),
+    "retry": ("TransportError('timed out')",),
+    "crash": (),
+}
+
+
+def reaction_to(msg: str) -> Reaction:
+    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):
+    return bool(reaction_to(msg))
+
+
+def YDL_log_filter(record: LogRecord):
+    if record.filename != "YoutubeDL.py":
+        return True
+
+    match record.levelname:
+        case "WARNING":
+            if "Falling back on generic information extractor" in record.msg:
+                return False
+        case "ERROR":
+            return not is_error_handle(record.msg)
+        case _:
+            return True

anime_sama_api/cli/internal_player.py

@@ -0,0 +1,58 @@
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+from rich import print
+
+from anime_sama_api.langs import Lang
+
+from .config import config
+from ..episode import Episode
+
+
+def open_silent_process(command: list[str]) -> subprocess.Popen:
+    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 | 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:
+    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,30 @@
+from ..episode import Episode
+
+
+class EpisodesManager:
+    def __init__(self, episodes: list[Episode], current_index=0) -> None:
+        self.episodes = episodes
+        self.current_index = current_index
+
+    def __next__(self):
+        if self.current_index < len(self.episodes) - 1:
+            self.current_index += 1
+            return self.episodes[self.current_index]
+
+        raise StopIteration
+
+    def previous(self):
+        if self.current_index > 0:
+            self.current_index -= 1
+            return self.episodes[self.current_index]
+
+        raise StopIteration
+
+    @property
+    def current(self):
+        return self.episodes[self.current_index]
+
+
+class PlayMenu:
+    def print_menu(self):
+        pass

anime_sama_api/cli/utils.py

@@ -0,0 +1,73 @@
+import sys
+from collections.abc import Callable
+from typing import TypeVar
+
+from rich import print as print_func
+
+input_func = input
+
+T = TypeVar("T")
+
+
+def safe_input(
+    text: str, transform: Callable[[str], T], exceptions=(ValueError, IndexError)
+) -> T:
+    while True:
+        try:
+            print_func(text, end="")
+            output = input_func()
+            return transform(output)
+        except exceptions:
+            pass
+
+
+def print_selection(choices: list, print_choices=True) -> None:
+    if len(choices) == 0:
+        print_func("[red]No result")
+        sys.exit(404)
+    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="Choose a number", **_) -> T:
+    print_selection(choices)
+    if len(choices) == 1:
+        return choices[0]
+
+    return safe_input(f"{msg}: \033[0;34m", lambda string: choices[int(string) - 1])
+
+
+def select_range(choices: list[T], msg="Choose a range", print_choices=True) -> list[T]:
+    print_selection(choices, print_choices)
+
+    if len(choices) == 1:
+        return [choices[0]]
+
+    def transform(string: str) -> list[T]:
+        ints_set = set()
+        for args in string.split(","):
+            ints = [int(num) for num in args.split("-")]
+
+            if len(ints) == 1:
+                ints_set.add(ints[0])
+            elif len(ints) == 2:
+                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"{msg} [green][1-{len(choices)}][/]: \033[0;34m",
+        transform,
+    )