anime-sama-cli 1.1__py3-none-any.whl

anime_sama_api/cli/episode_extra_info.py

@@ -0,0 +1,136 @@
+# Refactor is not a bad idea
+
+from dataclasses import dataclass
+from datetime import datetime
+from functools import lru_cache
+from typing import Any
+
+import httpx
+
+from anime_sama_api.catalogue import Catalogue
+from anime_sama_api.cli.utils import normalize
+from anime_sama_api.episode import Episode
+
+
+@dataclass(frozen=True)
+class EpisodeWithExtraInfo:
+    warpped: Episode
+    release_date: datetime | None = None
+
+    def release_year_parentheses(self) -> str:
+        if self.release_date is None:
+            return ""
+        return f" ({self.release_date.year})"
+
+
+def convert_with_extra_info(
+    episode: Episode, serie: Catalogue | None = None
+) -> EpisodeWithExtraInfo:
+    release_date = get_serie_release_date(serie) if serie is not None else None
+    return EpisodeWithExtraInfo(warpped=episode, release_date=release_date)
+
+
+en2fr_genre = {
+    "Comedy": "Comédie",
+    "Gourmet": "Gastronomie",
+    "Drama": "Drame",
+    "Adventure": "Aventure",
+    "Mystery": "Mystère",
+    "Sci-Fi": "Science-fiction",
+    "Sports": "Tournois",
+    "Supernatural": "Surnaturel",
+    "Girls Love": "Yuri",
+    "Horror": "Horreur",
+    "Fantasy": "Fantastique",
+}
+
+
+def get_serie_release_date(serie: Catalogue) -> datetime | None:
+    try:
+        anime = _get_mal_listing(serie)
+        if anime is None:
+            return None
+
+        iso_date = anime.get("aired", {}).get("from")
+        if iso_date is None:
+            return None
+
+        return datetime.fromisoformat(iso_date)
+    except httpx.HTTPStatusError:
+        return None
+
+
+@lru_cache(maxsize=128)
+def _get_mal_listing(serie: Catalogue) -> None | Any:
+    if not serie.is_anime:
+        return None
+
+    for name in [serie.name] + list(serie.alternative_names):
+        i = 0
+        while True:
+            try:
+                response = httpx.get(
+                    f"https://api.jikan.moe/v4/anime?q={name}&limit=5", timeout=10
+                )
+            except httpx.HTTPError:
+                return None
+
+            i += 1
+            if response.status_code != 429 or i > 9:
+                break
+
+        if response.status_code != 200:
+            return None
+
+        animes = response.json().get("data", [])
+
+        for anime in animes:
+            for title in anime.get("titles"):
+                name = normalize(name)
+                title = normalize(title.get("title"))
+                anime_genres = [genre.get("name") for genre in anime.get("genres")]
+                if name == title:
+                    # Also guess work but eliminate edge case like fate
+                    if len(anime_genres) == 0 and len(serie.genres) != 0:
+                        continue
+
+                    return anime
+
+                if name in title or title in name:
+                    if len(anime_genres) == 0:
+                        if len(serie.genres) != 0:
+                            continue
+                        else:
+                            return anime
+
+                    # Because this condition is not a guarantee, we do an additionnal screenning base on corresponding genres
+                    not_corresponding_genres = [
+                        genre
+                        for genre in anime_genres
+                        if genre not in serie.genres
+                        and en2fr_genre.get(genre) not in serie.genres
+                    ]
+
+                    # Very scientific formula. I'm joking it just guess work
+                    if len(not_corresponding_genres) / len(anime_genres) < 0.35 and (
+                        len(anime_genres) != 0 or len(serie.genres) == 0
+                    ):
+                        return anime
+
+    return None
+
+
+if __name__ == "__main__":
+    import asyncio
+    from anime_sama_api import find_site_url, AnimeSama
+
+    async def main():
+        url = await find_site_url()
+
+        if url is None:
+            raise
+
+        async for catalogue in AnimeSama(url).catalogues_iter():
+            print(catalogue.name, get_serie_release_date(catalogue))
+
+    asyncio.run(main())

anime_sama_api/cli/episode_tree.py

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+"""Affichage et sélection des épisodes via le widget Tree de Textual.
+↑↓ déplacer · Espace sélection · Tab déplier/replier · Entrée valider.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import App, ComposeResult
+from rich.text import Text
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import Static, Tree
+
+from anime_sama_api.episode import Episode
+from anime_sama_api.season import Season
+
+
+# Type pour les données d'un nœud : None (racine), liste d'épisodes (saison), ou un épisode (feuille)
+NodeData = Episode | list[Episode] | None
+
+
+class EpisodeTreeToggleSelection(Message):
+    """Message émis quand l'utilisateur appuie sur Espace pour (dé)sélectionner un nœud."""
+
+    def __init__(self, node: Any) -> None:
+        self.node = node
+        super().__init__()
+
+
+class EpisodeTreeConfirmSelection(Message):
+    """Message émis quand l'utilisateur appuie sur Entrée pour valider la sélection."""
+
+    pass
+
+
+class EpisodeTreeWidget(Tree[NodeData]):
+    """Tree personnalisé : Tab = déplier/replier, Espace = sélection, Entrée = valider."""
+
+    inherit_bindings = False
+
+    BINDINGS = [
+        Binding("up", "cursor_up", "Haut", show=False),
+        Binding("down", "cursor_down", "Bas", show=False),
+        Binding("tab", "toggle_node", "Déplier/Replier", show=False),
+        Binding("space", "toggle_selection", "Sélection", show=False),
+        Binding("enter", "confirm_selection", "Valider", show=False),
+    ]
+
+    def action_toggle_selection(self) -> None:
+        """Espace : ajoute ou retire le nœud courant de la sélection."""
+        node = self.cursor_node
+        if node is not None:
+            self.post_message(EpisodeTreeToggleSelection(node))
+
+    def action_confirm_selection(self) -> None:
+        """Entrée : valide la sélection et envoie le message à l'App."""
+        self.post_message(EpisodeTreeConfirmSelection())
+
+
+class EpisodeTree(App[list[Episode] | None]):
+    """Application Textual : tree des épisodes, tous les parents repliés.
+    Sélection multiple : parent = tout télécharger, enfants = épisodes choisis.
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quitter"),
+    ]
+
+    SUB_TITLE = "↑↓ déplacer · Espace Sélection · Tab déplier/replier · Entrée valider"
+
+    def __init__(
+        self,
+        season: Season,
+        episodes: list[Episode],
+        *,
+        title: str | None = None,
+    ) -> None:
+        super().__init__()
+        self._season = season
+        self._episodes = episodes
+        self._title = title or f"{season.serie_name} - {season.name}"
+        self._all_episodes: list[Episode] = list(episodes)
+        self._selected_node_ids: set[int] = set()
+
+    def compose(self) -> ComposeResult:
+        root_label = self._title
+        tree = EpisodeTreeWidget(root_label, data=None, id="episode-tree")
+        # Tous les parents restent repliés (on n'appelle pas expand())
+        for ep in self._episodes:
+            tree.root.add_leaf(ep.fancy_name, ep)
+        yield tree
+
+    def on_episode_tree_toggle_selection(self, message: EpisodeTreeToggleSelection) -> None:
+        """Espace : bascule la sélection du nœud sous le curseur."""
+        node = message.node
+        nid = node.id
+        if nid in self._selected_node_ids:
+            self._selected_node_ids.discard(nid)
+        else:
+            self._selected_node_ids.add(nid)
+        self._refresh_tree_labels()
+
+    def on_episode_tree_confirm_selection(self, _: EpisodeTreeConfirmSelection) -> None:
+        """Entrée : construit la liste d'épisodes sélectionnés et quitte."""
+        result = self._build_selected_episodes()
+        self.exit(result)
+
+    def _refresh_tree_labels(self) -> None:
+        """Marque visuellement les nœuds sélectionnés (✓) en mettant à jour les libellés."""
+        tree = self.query_one(EpisodeTreeWidget)
+        from textual.widgets._tree import TreeNode
+
+        def visit(node: TreeNode[NodeData]) -> None:
+            try:
+                plain = node.label.plain if hasattr(node.label, "plain") else str(node.label)
+                if node.id in self._selected_node_ids:
+                    if not plain.startswith("✓ "):
+                        node.set_label("✓ " + plain)
+                else:
+                    if plain.startswith("✓ "):
+                        node.set_label(plain[2:].strip())
+            except Exception:
+                pass
+            for child in node.children:
+                visit(child)
+
+        visit(tree.root)
+        tree.refresh()
+
+    def _build_selected_episodes(self) -> list[Episode]:
+        """À partir des nœuds sélectionnés, produit la liste d'épisodes (sans doublon, ordre conservé)."""
+        tree = self.query_one(EpisodeTreeWidget)
+        result: list[Episode] = []
+        seen: set[tuple[str, int]] = set()
+
+        for node_id in self._selected_node_ids:
+            try:
+                node = tree.get_node_by_id(node_id)
+            except Exception:
+                continue
+            to_add: list[Episode] = []
+            if node.is_root:
+                to_add = list(self._all_episodes)
+            elif isinstance(node.data, list):
+                to_add = node.data
+            elif isinstance(node.data, Episode):
+                to_add = [node.data]
+            for ep in to_add:
+                key = (ep.season_name, ep.index)
+                if key not in seen:
+                    seen.add(key)
+                    result.append(ep)
+        return result
+
+
+def run_episode_tree(
+    season: Season,
+    episodes: list[Episode],
+    *,
+    title: str | None = None,
+) -> list[Episode] | None:
+    """Affiche les épisodes en Tree (tous les parents repliés).
+    Espace = sélectionner/désélectionner (parent = toute la saison, enfants = épisodes).
+    Tab = déplier/replier un nœud. Entrée = valider. Retourne la liste des épisodes choisis ou None (q).
+    """
+    app = EpisodeTree(season, episodes, title=title)
+    app.run()
+    return app.return_value
+
+
+# Données des nœuds pour le tree multi-saisons : (Season, list[Episode]) pour une saison, (Season, Episode) pour une feuille
+MultiSeasonNodeData = tuple[Season, list[Episode]] | tuple[Season, Episode] | None
+
+
+# Raccourcis affichés en haut de la fenêtre de sélection
+TREE_HINTS = "↓↑ = naviguer · Esc = menu précédent · Tab = Déplier/Replier · Espace = Select · Entrée = Valider"
+
+
+def _load_ascii_art() -> str:
+    """Charge le contenu ASCII art du package (anime-sama)."""
+    try:
+        from importlib.resources import files
+        return (files("anime_sama_api") / "assets" / "ascii_art").read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+
+class MultiSeasonEpisodeTree(App[list[tuple[Season, Episode]] | None]):
+    """Tree Textual avec une saison par nœud parent collapsible.
+    Structure : Racine > Saison 1 (▶) > Episode 1, 2, … ; Saison 2 (▶) > …
+    """
+
+    TITLE = ""
+    SUB_TITLE = ""
+
+    BINDINGS = [
+        ("q", "quit", "Quitter"),
+        ("escape", "quit", "Menu précédent"),
+    ]
+
+    # Fond sombre type terminal ; ASCII art + indications
+    CSS = """
+    Screen {
+        background: #0c0c0c;
+    }
+    Header {
+        display: none;
+    }
+    #tree-ascii-art {
+        padding: 0 1 0 1;
+        padding-left: 2;
+        margin-top: 1;
+        margin-bottom: 1;
+        background: #0c0c0c;
+        color: #00bfff;
+        height: auto;
+    }
+    #tree-hints {
+        padding: 0 1 0 1;
+        background: #0c0c0c;
+        color: #a0a0a0;
+        text-style: dim;
+        height: auto;
+    }
+    #episode-tree {
+        background: #0c0c0c;
+        padding: 0 0 0 0;
+    }
+    """
+
+    def __init__(
+        self,
+        seasons_with_episodes: list[tuple[Season, list[Episode]]],
+        *,
+        title: str = "Saisons",
+    ) -> None:
+        super().__init__()
+        self._seasons_with_episodes = seasons_with_episodes
+        self._title = title
+        self._selected_node_ids: set[int] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Static(TREE_HINTS, id="tree-hints")
+        ascii_art = _load_ascii_art()
+        if ascii_art:
+            yield Static(Text(ascii_art, style="bold cyan"), id="tree-ascii-art")
+        tree = EpisodeTreeWidget(self._title, data=None, id="episode-tree")
+        for season, episodes in self._seasons_with_episodes:
+            season_node = tree.root.add(
+                season.name,
+                data=(season, episodes),
+                expand=False,
+            )
+            for ep in episodes:
+                label = ep.name.strip() if getattr(ep, "name", None) else f"Episode {ep.index}"
+                season_node.add_leaf(label, (season, ep))
+        yield tree
+
+    def on_episode_tree_toggle_selection(self, message: EpisodeTreeToggleSelection) -> None:
+        node = message.node
+        nid = node.id
+        if nid in self._selected_node_ids:
+            self._selected_node_ids.discard(nid)
+        else:
+            self._selected_node_ids.add(nid)
+        self._refresh_tree_labels()
+
+    def on_episode_tree_confirm_selection(self, _: EpisodeTreeConfirmSelection) -> None:
+        result = self._build_selected()
+        self.exit(result)
+
+    def _refresh_tree_labels(self) -> None:
+        tree = self.query_one(EpisodeTreeWidget)
+        from textual.widgets._tree import TreeNode
+
+        def visit(node: TreeNode[MultiSeasonNodeData]) -> None:
+            try:
+                plain = node.label.plain if hasattr(node.label, "plain") else str(node.label)
+                if node.id in self._selected_node_ids:
+                    if not plain.startswith("✓ "):
+                        node.set_label("✓ " + plain)
+                else:
+                    if plain.startswith("✓ "):
+                        node.set_label(plain[2:].strip())
+            except Exception:
+                pass
+            for child in node.children:
+                visit(child)
+
+        visit(tree.root)
+        tree.refresh()
+
+    def _build_selected(self) -> list[tuple[Season, Episode]]:
+        tree = self.query_one(EpisodeTreeWidget)
+        result: list[tuple[Season, Episode]] = []
+        seen: set[tuple[str, int]] = set()
+
+        for node_id in self._selected_node_ids:
+            try:
+                node = tree.get_node_by_id(node_id)
+            except Exception:
+                continue
+            to_add: list[tuple[Season, Episode]] = []
+            if node.is_root:
+                for s, eps in self._seasons_with_episodes:
+                    to_add.extend((s, ep) for ep in eps)
+            elif isinstance(node.data, tuple):
+                if len(node.data) == 2:
+                    s, val = node.data
+                    if isinstance(val, list):
+                        to_add = [(s, ep) for ep in val]
+                    else:
+                        to_add = [(s, val)]
+            for s, ep in to_add:
+                key = (ep.season_name, ep.index)
+                if key not in seen:
+                    seen.add(key)
+                    result.append((s, ep))
+        return result
+
+
+def run_multi_season_episode_tree(
+    seasons_with_episodes: list[tuple[Season, list[Episode]]],
+    *,
+    title: str = "Saisons",
+) -> list[tuple[Season, Episode]] | None:
+    """Tree collapsible multi-saisons (synchrone, utilise asyncio.run())."""
+    app = MultiSeasonEpisodeTree(seasons_with_episodes, title=title)
+    app.run()
+    return app.return_value
+
+
+async def run_multi_season_episode_tree_async(
+    seasons_with_episodes: list[tuple[Season, list[Episode]]],
+    *,
+    title: str = "Saisons",
+) -> list[tuple[Season, Episode]] | None:
+    """Tree collapsible multi-saisons (async, pour boucle asyncio déjà en cours).
+    À utiliser depuis un flux async au lieu de run_multi_season_episode_tree.
+    """
+    app = MultiSeasonEpisodeTree(seasons_with_episodes, title=title)
+    await app.run_async()
+    return app.return_value

anime_sama_api/cli/error_handeling.py

@@ -0,0 +1,79 @@
+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",
+        "Requested format is not available",
+        "Unable to extract player params",
+        "Unable to extract",
+    ),
+    "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":
+            if any(
+                msg in record.msg
+                for msg in (
+                    "Falling back on generic information extractor",
+                    "Live HLS streams are not supported by the native downloader.",
+                )
+            ):
+                return False
+            return True
+        case "ERROR":
+            # Ne pas afficher les erreurs qu'on gère (passage au lecteur suivant)
+            if is_error_handle(record.msg):
+                return False
+            return True
+        case "CRITICAL":
+            # Ne pas afficher CRITICAL quand on a simplement essayé un lecteur et on passe au suivant
+            if is_error_handle(record.msg):
+                return False
+            return True
+        case _:
+            return True

anime_sama_api/cli/internal_player.py

@@ -0,0 +1,61 @@
+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 = list(config.internal_player_command) + [best]
+    # VLC : une instance par épisode ; fermeture de la fenêtre = VLC quitte complètement (pas de tray).
+    if player_command and "vlc" in player_command[0].lower():
+        for opt in ("--no-one-instance", "--no-qt-system-tray"):
+            if opt not in player_command:
+                player_command.insert(1, opt)
+    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,30 @@
+from anime_sama_api.episode import Episode
+
+
+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