anime-sama-api 0.2.2.post4__tar.gz → 0.3.0__tar.gz

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/.github/workflows/ci.yaml

@@ -11,11 +11,11 @@ jobs:
       matrix:
         os: [ubuntu-latest, windows-latest]
         python-version:
-          - "3.10"
           - "3.11"
           - "3.12"
           - "3.13"
           - "3.14"
+          - "3.15"
 
     name: Test
     runs-on: ${{ matrix.os }}
@@ -26,7 +26,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v5
         with:
-          version: "0.6.3"
+          version: "0.13.3"
           python-version: ${{ matrix.python-version }}
           enable-cache: true
           cache-dependency-glob: "uv.lock"

anime_sama_api-0.3.0/.python-version

@@ -0,0 +1 @@
+3.11

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: anime-sama_api
-Version: 0.2.2.post4
+Version: 0.3.0
 Summary: Api for anime-sama
 Project-URL: Repository, https://github.com/Sky-NiniKo/anime-sama_api/
 Author-email: NiniKo <pcninik@gmail.com>
@@ -12,19 +12,17 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Video :: Capture
 Classifier: Topic :: System :: Archiving
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: httpx>=0.28.1
 Provides-Extra: cli
-Requires-Dist: platformdirs>=4.5.1; extra == 'cli'
-Requires-Dist: rich>=14.2.0; extra == 'cli'
-Requires-Dist: tomli>=2.2.1; (python_full_version < '3.11') and extra == 'cli'
-Requires-Dist: yt-dlp>=2025.8.22; extra == 'cli'
+Requires-Dist: platformdirs>=4.13.5; extra == 'cli'
+Requires-Dist: rich>=15.0.0; extra == 'cli'
+Requires-Dist: yt-dlp>=2026.8.19; extra == 'cli'
 Description-Content-Type: text/markdown
 
 This project is archive. I do not have the time to work on it anymore. I may make some small fixes if a breaking issue arises. 
@@ -36,7 +34,7 @@ I have implemented all the features I care about. This project is now in mainten
 
 # Installation
 Requirements:
-- Python 3.10 or higher
+- Python 3.11 or higher
 
 You can simply install it with (note that you can use tools like pipx to isolate the installation):
 ```bash

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/README.md

@@ -7,7 +7,7 @@ I have implemented all the features I care about. This project is now in mainten
 
 # Installation
 Requirements:
-- Python 3.10 or higher
+- Python 3.11 or higher
 
 You can simply install it with (note that you can use tools like pipx to isolate the installation):
 ```bash

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/__init__.py

@@ -19,26 +19,26 @@ except ImportError:
 
         sys.exit(1)
 
-    download = multi_download = main  # type: ignore
+    download = multi_download = main
 
 
 # __package__ = "anime-sama_api"
 __all__ = [
     "AnimeSama",
     "Catalogue",
-    "Season",
-    "Players",
-    "Languages",
     "Episode",
     "Lang",
     "LangId",
-    "lang2ids",
-    "id2lang",
-    "flags",
+    "Languages",
+    "Players",
+    "Season",
     "download",
-    "multi_download",
-    "main",
     "find_site_url",
+    "flags",
+    "id2lang",
+    "lang2ids",
+    "main",
+    "multi_download",
 ]
 
 """__locals = locals()

anime_sama_api-0.3.0/anime_sama_api/catalogue.py

@@ -0,0 +1,252 @@
+import logging
+import re
+from collections.abc import Sequence
+from datetime import date
+from html import unescape
+from typing import Literal, get_args
+
+from httpx import AsyncClient
+
+from .langs import Lang, flags
+from .season import Season
+from .utils import remove_some_js_comments
+
+Type = Literal["Anime", "Film", "Scans", "Webtoon", "Autres"]
+State = Literal["À venir", "En cours", "Terminé", "Annulé", "En pause"]
+
+logger = logging.getLogger(__name__)
+
+
+class Catalogue:
+    def __init__(
+        self,
+        url: str,
+        name: str = "",
+        alternative_names: Sequence[str] | None = None,
+        genres: Sequence[str] | None = None,
+        types: set[Type] | None = None,
+        languages: set[Lang] | None = None,
+        image_url: str = "",
+        client: AsyncClient | None = None,
+    ) -> None:
+        if alternative_names is None:
+            alternative_names = []
+        if genres is None:
+            genres = []
+        if types is None:
+            types = set()
+        if languages is None:
+            languages = set()
+
+        self.url = url + "/" if url[-1] != "/" else url
+        self.site_url = "/".join(url.split("/")[:3]) + "/"
+        self.client = client or AsyncClient()
+
+        self.name = name or url.split("/")[-2]
+
+        self._page: str | None = None
+        self.alternative_names = alternative_names
+        self.genres = genres
+        self.types = types
+        self.languages = languages
+        self.image_url = image_url
+
+    async def page(self) -> str:
+        if self._page is not None:
+            return self._page
+
+        response = await self.client.get(self.url)
+
+        if response.is_error:
+            self._page = ""
+        else:
+            self._page = response.text
+
+        return self._page
+
+    async def seasons(self) -> list[Season]:
+        page_without_comments = remove_some_js_comments(string=await self.page())
+
+        seasons = re.findall(
+            r'panneauAnime\("(.+?)", *"(.+?)(?:vostfr|vf)"\);', page_without_comments
+        )
+
+        seasons = [
+            Season(
+                url=self.url + link,
+                name=name,
+                series_name=self.name,
+                client=self.client,
+            )
+            for name, link in seasons
+        ]
+
+        return seasons
+
+    async def _info_values(self) -> dict[str, list[str]]:
+        values: dict[str, list[str]] = {}
+        page = await self.page()
+        info_blocks = re.findall(
+            r"""<dl\b[^>]*class=["'][^"']*\boe-infos\b[^"']*["'][^>]*>(.*?)</dl\s*>""",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+        for block in info_blocks:
+            for label, value in re.findall(
+                r"<dt\b[^>]*>(.*?)</dt\s*>\s*<dd\b[^>]*>(.*?)</dd\s*>",
+                block,
+                re.IGNORECASE | re.DOTALL,
+            ):
+                clean_label = self._clean_html(label).casefold()
+                values.setdefault(clean_label, []).append(self._clean_html(value))
+        return values
+
+    # TODO: move to utils
+    @staticmethod
+    def _clean_html(value: str) -> str:
+        return re.sub(r"\s+", " ", unescape(re.sub(r"<[^>]*>", " ", value))).strip()
+
+    async def news(self) -> str:
+        search = re.findall(r"Actualité.+?>(.+?)<", await self.page())
+
+        if not search:
+            return ""
+
+        return search[0].lstrip()
+
+    async def state(self) -> str:
+        info = await self._info_values()
+        states = info.get("statut", [])
+        if states:
+            if states[0] in get_args(State):
+                return states[0]
+            logger.warning(
+                f"Error while parsing '{states[0]}'. \nPlease report this to the developer with URL: {self.url}",
+            )
+        return ""
+
+    async def broadcasting_date(self) -> date | None:
+        raise NotImplementedError
+
+        info = await self._info_values()
+        diffusions = info.get("diffusion", [])
+
+        if not diffusions:
+            return
+
+        import time
+
+        return date(
+            *(time.strptime(diffusions[0], "%d %b. %Y")[0:3])
+        )  # issue with local: %b should be interpreted with french local
+
+    async def year(self) -> int | None:
+        info = await self._info_values()
+        for label in ("diffusion", "année", "année de sortie", "début"):
+            for value in info.get(label, []):
+                match = re.search(r"\b(?:19|20)\d{2}\b", value)
+                if match:
+                    return int(match.group(0))
+
+    async def episode_count(self) -> int | None:
+        info = await self._info_values()
+        for value in info.get("épisodes", []):
+            match = re.search(r"\d+", value)
+            if match:
+                return int(match.group(0))
+
+    # Currently not provided by Anime Sama. We consider this as deprecated: TODO add a warning
+    async def chapter_count(self) -> int | None:
+        info = await self._info_values()
+        for value in info.get("chapitres", []):
+            match = re.search(r"\d+", value)
+            if match:
+                return int(match.group(0))
+
+    async def creator(self) -> str:
+        info = await self._info_values()
+        creators = info.get("auteur", [])
+
+        if not creators:
+            return ""
+
+        return creators[0]
+
+    async def studio(self) -> str:
+        info = await self._info_values()
+        studios = info.get("studio", [])
+
+        if not studios:
+            return ""
+
+        return studios[0]
+
+    async def correspondence(self) -> str:
+        page = await self.page()
+        match = re.search(
+            r"Correspondance\s*:.*?</strong>\s*(.*?)</span>",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+
+        if not match:
+            return ""
+
+        return self._clean_html(match.group(1))
+
+    async def synopsis(self) -> str:
+        page = await self.page()
+        synopsis = re.search(
+            r"""<p\b[^>]*id=["'][^"']*\bsynopsisText\b[^"']*["'][^>]*>(.*?)</p\s*>""",
+            page,
+            re.IGNORECASE | re.DOTALL,
+        )
+
+        if not synopsis:
+            return ""
+
+        return self._clean_html(synopsis.group(1))
+
+    async def is_mature(self) -> bool:
+        """Return True if the catalogue contain a warning about adult content"""
+        return (
+            re.search(
+                r'<div class=".*?yellow.*?">[\W\w]+?public averti', await self.page()
+            )
+            is not None
+        )
+
+    @property
+    def is_anime(self) -> bool:
+        return "Anime" in self.types
+
+    @property
+    def is_manga(self) -> bool:
+        return "Scans" in self.types
+
+    @property
+    def is_film(self) -> bool:
+        return "Film" in self.types
+
+    @property
+    def is_other(self) -> bool:
+        return "Autres" in self.types
+
+    @property
+    def fancy_name(self) -> str:
+        names = [""] + list(self.alternative_names) if self.alternative_names else []
+        return f"{self.name}[bright_black]{' - '.join(names)} {' '.join(flags[lang] for lang in self.languages if lang != 'VOSTFR')}"
+
+    def __repr__(self) -> str:
+        return f"Catalogue({self.url!r}, {self.name!r})"
+
+    def __str__(self) -> str:
+        return self.fancy_name
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Catalogue):
+            return False
+        return self.url == value.url
+
+    def __hash__(self) -> int:
+        return hash(self.url + self.name + "".join(self.alternative_names))

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/cli/__main__.py

@@ -9,8 +9,8 @@ from rich.status import Status
 
 from anime_sama_api.cli import downloader, internal_player
 from anime_sama_api.cli.config import config
-from anime_sama_api.cli.episode_extra_info import convert_with_extra_info
 from anime_sama_api.cli.utils import safe_input, select_one, select_range
+from anime_sama_api.season import EpisodeDataUnavailableError
 from anime_sama_api.top_level import AnimeSama, find_site_url
 
 console = get_console()
@@ -53,17 +53,14 @@ async def async_main() -> None:
         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}")
+        console.print(f"\n[cyan bold underline]{season.series_name} - {season.name}")
         selected_episodes = select_range(
             episodes, msg="Choose episode(s)", print_choices=True
         )
 
     if config.download:
         downloader.multi_download(
-            [
-                convert_with_extra_info(episode, catalogue)
-                for episode in selected_episodes
-            ],
+            selected_episodes,
             config.download_path,
             config.episode_path,
             config.concurrent_downloads,
@@ -72,6 +69,7 @@ async def async_main() -> None:
             config.max_retry_time,
             config.format,
             config.format_sort,
+            [await catalogue.year()] * len(selected_episodes),
         )
     else:
         command = internal_player.play_episode(
@@ -86,6 +84,9 @@ def main() -> int:
         asyncio.run(async_main())
     except (KeyboardInterrupt, asyncio.exceptions.CancelledError, EOFError):
         console.print("\n[red]Exiting...")
+    except EpisodeDataUnavailableError as error:
+        console.print(f"\n[red]{error}")
+        return 1
 
     return 0
 

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/cli/config.py

@@ -1,6 +1,6 @@
 # TODO: Allway hard to read but I can't find a better way to do it
 import logging
-import sys
+import tomllib
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -9,11 +9,6 @@ from platformdirs import user_config_dir, user_downloads_dir
 
 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__)
 
 

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/cli/config.toml

@@ -4,8 +4,8 @@ prefer_languages = ["VOSTFR"]
 
 # Where to put the downloads
 download_path = "~/Downloads/Anime-Sama"
-# How to organize the downloads (you can use {serie} {season} {episode} {release_year_parentheses})
-episode_path = "{serie}/{season}/{episode}"
+# How to organize the downloads (you can use {series} {season} {episode} {release_year_parentheses})
+episode_path = "{series}/{season}/{episode}"
 
 # If it downloads or plays the selected episodes
 download = true
@@ -13,7 +13,7 @@ show_players = false
 max_retry_time = 1024
 
 # See https://github.com/yt-dlp/yt-dlp#format-selection
-# For exemple, if you want the lowest size, put "+size,+br,+res,+fps" in format_sort
+# For example, if you want the lowest size, put "+size,+br,+res,+fps" in format_sort
 format = "all"
 format_sort = ""
 

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/cli/downloader.py

@@ -24,10 +24,10 @@ from rich.table import Column
 from yt_dlp import YoutubeDL
 from yt_dlp.utils import DownloadError
 
-from anime_sama_api.langs import Lang
 from anime_sama_api.cli.config import PlayersConfig, config
-from anime_sama_api.cli.episode_extra_info import EpisodeWithExtraInfo
-from anime_sama_api.cli.error_handeling import YDL_log_filter, reaction_to
+from anime_sama_api.cli.error_handling import YDL_log_filter, reaction_to
+from anime_sama_api.episode import Episode
+from anime_sama_api.langs import Lang
 
 logger = logging.getLogger(__name__)
 logger.addFilter(YDL_log_filter)
@@ -64,7 +64,7 @@ progress = Group(total_progress, download_progress)
 
 
 def download(
-    episode: EpisodeWithExtraInfo,
+    episode: Episode,
     path: Path,
     episode_path: str = "{episode}",
     prefer_languages: list[Lang] | None = None,
@@ -73,28 +73,29 @@ def download(
     max_retry_time: int = 1024,
     video_format: str = "",
     format_sort: str = "",
+    ep_year: int | None = None,
 ) -> None:
     if prefer_languages is None:
         prefer_languages = ["VOSTFR"]
     if players_config is None:
         players_config = PlayersConfig([], [])
 
-    if not any(episode.warpped.languages.values()):
+    if not any(episode.languages.values()):
         logger.error("No player available")
         return
 
     me = download_progress.add_task(
-        "download", episode_name=episode.warpped.name, site="", total=None
+        "download", episode_name=episode.name, site="", total=None
     )
     task = next(t for t in download_progress.tasks if t.id == me)
 
     full_path = (
         path
         / episode_path.format(
-            serie=episode.warpped.serie_name,
-            season=episode.warpped.season_name,
-            episode=episode.warpped.name,
-            release_year_parentheses=episode.release_year_parentheses(),
+            series=episode.series_name,
+            season=episode.season_name,
+            episode=episode.name,
+            release_year_parentheses="" if ep_year is None else f" {ep_year}",
         )
     ).expanduser()
 
@@ -115,11 +116,11 @@ def download(
         "format_sort": format_sort.split(","),
     }
 
-    for player in episode.warpped.consume_player(
+    for player in episode.consume_player(
         prefer_languages, players_config.prefers, players_config.bans
     ):
         retry_time = 1
-        sucess = False
+        success = False
         download_progress.update(me, site=urlparse(player).hostname)
 
         while True:
@@ -128,7 +129,7 @@ def download(
                     error_code = cast(int, ydl.download([player]))
 
                     if not error_code:
-                        sucess = True
+                        success = True
                     else:
                         logger.fatal(
                             "The download encountered an error code %s. Please report this to the developer with URL: %s",
@@ -149,7 +150,7 @@ def download(
 
                         logger.warning(
                             "%s interrupted (%s). Retrying in %ss.",
-                            episode.warpped.name,
+                            episode.name,
                             exception.msg,
                             retry_time,
                         )
@@ -158,7 +159,7 @@ def download(
                         retry_time *= 2
 
                     case "crash":
-                        raise exception
+                        raise  # Reraise the same exception
 
                     case "":
                         logger.fatal(
@@ -167,7 +168,7 @@ def download(
                         )
                         break
 
-        if sucess:
+        if success:
             break
 
     download_progress.update(me, visible=False)
@@ -176,7 +177,7 @@ def download(
 
 
 def multi_download(
-    episodes: list[EpisodeWithExtraInfo],
+    episodes: list[Episode],
     path: Path,
     episode_path: str = "{episode}",
     concurrent_downloads: dict[str, int] | None = None,
@@ -185,6 +186,7 @@ def multi_download(
     max_retry_time: int = 1024,
     video_format: str = "",
     format_sort: str = "",
+    eps_years: list[int | None] | None = None,
 ) -> None:
     if concurrent_downloads is None:
         concurrent_downloads = {}
@@ -193,24 +195,29 @@ def multi_download(
     if players_config is None:
         players_config = PlayersConfig([], [])
 
+    # Ensure eps_years len
+    if eps_years is None:
+        eps_years = []
+    eps_years += [None] * (len(episodes) - len(eps_years))
+    eps_years = eps_years[: len(episodes)]
+
     """
     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,
-                    episode_path,
-                    prefer_languages,
-                    players_config,
-                    concurrent_downloads.get("fragment", 1),
-                    max_retry_time,
-                    video_format,
-                    format_sort,
-                )
+    with Live(progress, console=console), ThreadPoolExecutor(
+        max_workers=concurrent_downloads.get("video", 1)
+    ) as executor:
+        for episode, ep_year in zip(episodes, eps_years):
+            executor.submit(
+                download,
+                episode,
+                path,
+                episode_path,
+                prefer_languages,
+                players_config,
+                concurrent_downloads.get("fragment", 1),
+                max_retry_time,
+                video_format,
+                format_sort,
+            )

anime_sama_api-0.2.2.post4/anime_sama_api/cli/error_handeling.py → anime_sama_api-0.3.0/anime_sama_api/cli/error_handling.py

@@ -53,15 +53,13 @@ def YDL_log_filter(record: LogRecord) -> bool:
 
     match record.levelname:
         case "WARNING":
-            if any(
-                msg in record.msg
+            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.",
                 )
-            ):
-                return False
-            return True
+            )
         case "ERROR":
             return not is_error_handle(record.msg)
         case _:

{anime_sama_api-0.2.2.post4 → anime_sama_api-0.3.0}/anime_sama_api/cli/utils.py

@@ -1,7 +1,7 @@
 import re
 import sys
 from collections.abc import Callable
-from typing import Any, TypeVar, cast
+from typing import Any, TypeVar
 
 from rich import print as print_func
 
@@ -82,7 +82,7 @@ def select_range(
                     ints[0] = 1
                 if ints[1] is None:
                     ints[1] = len(choices)
-                ints_set.update(range(cast(int, ints[0]), cast(int, ints[1]) + 1))
+                ints_set.update(range(ints[0], ints[1] + 1))
             else:
                 raise ValueError