anipy-api 3.0.0__tar.gz

anipy_api-3.0.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: anipy-api
+Version: 3.0.0
+Summary: api for anipy-cli
+Home-page: https://sdaqo.github.io/anipy-cli
+License: GPL-3.0
+Keywords: anime,api
+Author: sdaqo
+Author-email: sdaqo.dev@protonmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
+Requires-Dist: dataclasses-json (>=0.6.4,<0.7.0)
+Requires-Dist: levenshtein (>=0.25.1,<0.26.0)
+Requires-Dist: m3u8 (>=4.1.0,<5.0.0)
+Requires-Dist: pycryptodomex (>=3.20.0,<4.0.0)
+Requires-Dist: pypresence (>=4.3.0,<5.0.0)
+Requires-Dist: python-ffmpeg (>=2.0.11,<3.0.0)
+Requires-Dist: python-mpv (>=1.0.6,<2.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Project-URL: Bug Tracker, https://github.com/sdaqo/anipy-cli/issues
+Project-URL: Documentation, https://sdaqo.github.io/anipy-cli/getting-started-api
+Project-URL: Repository, https://github.com/sdaqo/anipy-cli
+Description-Content-Type: text/markdown
+
+# anipy-api
+This is the api package for [anipy-cli](https://pypi.org/project/anipy-cli/).
+
+Find documentation here: [https://sdaqo.github.io/anipy-cli/getting-started-api](https://sdaqo.github.io/anipy-cli/getting-started-api)
+

anipy_api-3.0.0/README.md

@@ -0,0 +1,4 @@
+# anipy-api
+This is the api package for [anipy-cli](https://pypi.org/project/anipy-cli/).
+
+Find documentation here: [https://sdaqo.github.io/anipy-cli/getting-started-api](https://sdaqo.github.io/anipy-cli/getting-started-api)

anipy_api-3.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[tool.poetry]
+name = "anipy-api"
+version = "3.0.0"
+description = "api for anipy-cli"
+authors = ["sdaqo <sdaqo.dev@protonmail.com>"]
+license = "GPL-3.0"
+repository = "https://github.com/sdaqo/anipy-cli"
+homepage = "https://sdaqo.github.io/anipy-cli"
+documentation = "https://sdaqo.github.io/anipy-cli/getting-started-api"
+keywords = ["anime", "api"]
+readme = "README.md"
+packages = [
+  {include = "anipy_api", from = "src"}
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+python-ffmpeg = "^2.0.11"
+pycryptodomex = "^3.20.0"
+requests = "^2.31.0"
+pypresence = "^4.3.0"
+m3u8 = "^4.1.0"
+beautifulsoup4 = "^4.12.3"
+python-mpv = "^1.0.6"
+dataclasses-json = "^0.6.4"
+levenshtein = "^0.25.1"
+
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/sdaqo/anipy-cli/issues"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+

anipy_api-3.0.0/src/anipy_api/__init__.py

@@ -0,0 +1,2 @@
+__appname__ = "anipy-api"
+__version__ = "3.0.0"

anipy_api-3.0.0/src/anipy_api/anime.py

@@ -0,0 +1,161 @@
+from typing import TYPE_CHECKING, Optional, Set, Union, List
+
+from anipy_api.provider import Episode, list_providers
+
+if TYPE_CHECKING:
+    from anipy_api.locallist import LocalListEntry
+    from anipy_api.provider import (
+        BaseProvider,
+        LanguageTypeEnum,
+        ProviderSearchResult,
+        ProviderInfoResult,
+        ProviderStream,
+    )
+
+
+class Anime:
+    """A wrapper class that represents an anime, it is pretty useful, but you
+    can also just use the [Provider][anipy_api.provider.base.BaseProvider] without the wrapper.
+
+    Args:
+        provider: The provider from which the identifier was retrieved
+        name: The name of the Anime
+        identifier: The identifier of the Anime
+        languages: Supported Language types of the Anime
+
+    Attributes:
+        provider: The from which the Anime comes from
+        name: The name of the Anime
+        identifier: The identifier of the Anime
+        languages: Set of supported Language types of the Anime
+    """
+
+    @staticmethod
+    def from_search_result(
+        provider: "BaseProvider", result: "ProviderSearchResult"
+    ) -> "Anime":
+        """Get Anime object from ProviderSearchResult.
+
+        Args:
+            provider: The provider from which the search result stems from
+            result: The search result
+
+        Returns:
+            Anime object
+        """
+        return Anime(provider, result.name, result.identifier, result.languages)
+
+    @staticmethod
+    def from_local_list_entry(entry: "LocalListEntry") -> "Anime":
+        """Get Anime object from [LocalListEntry][anipy_api.locallist.LocalListEntry]
+
+        Args:
+            entry: The local list entry
+
+        Returns:
+            Anime Object
+        """
+        provider = next(filter(lambda x: x.NAME == entry.provider, list_providers()))
+        return Anime(provider(), entry.name, entry.identifier, entry.languages)
+
+    def __init__(
+        self,
+        provider: "BaseProvider",
+        name: str,
+        identifier: str,
+        languages: Set["LanguageTypeEnum"],
+    ):
+        self.provider: "BaseProvider" = provider
+        self.name: str = name
+        self.identifier: str = identifier
+        self.languages: Set["LanguageTypeEnum"] = languages
+
+    def get_episodes(self, lang: "LanguageTypeEnum") -> List["Episode"]:
+        """Get a list of episodes from the Anime.
+
+        Args:
+            lang: Language type that determines if episodes are searched
+                for the dub or sub version of the Anime. Use the `languages`
+                attribute to get supported languages for this Anime.
+
+        Returns:
+            List of Episodes
+        """
+        return self.provider.get_episodes(self.identifier, lang)
+
+    def get_info(self) -> "ProviderInfoResult":
+        """Get information about the Anime.
+
+        Returns:
+            ProviderInfoResult object
+        """
+        return self.provider.get_info(self.identifier)
+
+    def get_video(
+        self,
+        episode: Episode,
+        lang: "LanguageTypeEnum",
+        preferred_quality: Optional[Union[str, int]] = None,
+    ) -> "ProviderStream":
+        """Get a video stream for the specified episode, the quality to return
+        is determined by the `preferred_quality` argument or if this is not
+        defined by the best quality found. To get a list of streams use
+        [get_videos][anipy_api.anime.Anime.get_videos].
+
+        Args:
+            episode: The episode to get the stream for
+            lang: Language type that determines if streams are searched for
+                the dub or sub version of the Anime. Use the `languages`
+                attribute to get supported languages for this Anime.
+            preferred_quality: This may be a integer (e.g. 1080, 720 etc.)
+                or the string "worst" or "best".
+
+        Returns:
+            A stream
+        """
+        streams = self.provider.get_video(self.identifier, episode, lang)
+        streams.sort(key=lambda s: s.resolution)
+
+        if preferred_quality == "worst":
+            stream = streams[0]
+        elif preferred_quality == "best":
+            stream = streams[-1]
+        elif preferred_quality is None:
+            stream = streams[-1]
+        else:
+            stream = next(
+                filter(lambda s: s.resolution == preferred_quality, streams), None
+            )
+
+            if stream is None:
+                stream = streams[-1]
+
+        return stream
+
+    def get_videos(
+        self, episode: Episode, lang: "LanguageTypeEnum"
+    ) -> List["ProviderStream"]:
+        """Get a list of video streams for the specified Episode.
+
+        Args:
+            episode: The episode to get the streams for
+            lang: Language type that determines if streams are searched for
+                the dub or sub version of the Anime. Use the `languages`
+                attribute to get supported languages for this Anime.
+
+        Returns:
+            A list of streams sorted by quality
+        """
+        streams = self.provider.get_video(self.identifier, episode, lang)
+        streams.sort(key=lambda s: s.resolution)
+
+        return streams
+
+    def __repr__(self) -> str:
+        available_langs = "/".join(
+            [lang.value.capitalize()[0] for lang in self.languages]
+        )
+        return f"{self.name} ({available_langs})"
+
+    def __hash__(self) -> int:
+        return hash(self.provider.NAME + self.identifier)

anipy_api-3.0.0/src/anipy_api/download.py

@@ -0,0 +1,306 @@
+import json
+import shutil
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Optional, Protocol
+from urllib.parse import urljoin
+
+import m3u8
+import requests
+from ffmpeg import FFmpeg, Progress
+from requests.adapters import HTTPAdapter, Retry
+
+from anipy_api.error import DownloadError
+from anipy_api.provider import ProviderStream
+
+
+class ProgressCallback(Protocol):
+    """Callback that accepts a percentage argument."""
+
+    def __call__(self, percentage: float):
+        """
+        Args:
+            percentage: Percentage argument passed to the callback
+        """
+        ...
+
+
+class InfoCallback(Protocol):
+    """Callback that accepts a message argument."""
+
+    def __call__(self, message: str):
+        """
+        Args:
+            message: Message argument passed to the callback
+        """
+        ...
+
+
+class Downloader:
+    """Downloader class to download streams retrieved by the Providers."""
+
+    def __init__(
+        self,
+        progress_callback: Optional[ProgressCallback] = None,
+        info_callback: Optional[InfoCallback] = None,
+    ):
+        """__init__ of Downloader.
+
+        Args:
+            progress_callback: A callback with an percentage argument, that gets called on download progress.
+            info_callback: A callback with an message argument, that gets called on certain events.
+        """
+        self._progress_callback: ProgressCallback = progress_callback or (
+            lambda percentage: None
+        )
+        self._info_callback: InfoCallback = info_callback or (lambda message: None)
+
+        self._session = requests.Session()
+
+        adapter = HTTPAdapter(max_retries=Retry(connect=3, backoff_factor=0.5))
+        self._session.mount("http://", adapter)
+        self._session.mount("https://", adapter)
+
+    @staticmethod
+    def _get_valid_pathname(name: str):
+        if sys.platform == "win32":
+            WIN_INVALID_CHARS = ["\\", "/", ":", "*", "?", "<", ">", "|", '"']
+            name = "".join(["" if x in WIN_INVALID_CHARS else x for x in name])
+
+        name = "".join(
+            [i for i in name if i.isascii()]
+        )  # Verify all chars are ascii (eject if not)
+
+        return name
+
+    def m3u8_download(self, stream: "ProviderStream", download_path: Path) -> Path:
+        """Download a m3u8/hls stream to a specified download path in a ts container.
+
+        The suffix of the download path will be replaced (or added) with
+        ".ts", use the path returned instead of the passed path.
+
+        Args:
+            stream: The m3u8/hls stream
+            download_path: The path to save the downloaded stream to
+
+        Raises:
+            DownloadError: Raised on download error
+
+        Returns:
+            The path with a ".ts" suffix
+        """
+        temp_folder = download_path.parent / "temp"
+        temp_folder.mkdir(exist_ok=True)
+        download_path = download_path.with_suffix(".ts")
+
+        res = self._session.get(stream.url)
+        res.raise_for_status()
+
+        m3u8_content = m3u8.M3U8(res.text, base_uri=urljoin(res.url, "."))
+
+        assert m3u8_content.is_variant is False
+
+        counter = 0
+
+        def download_ts(segment: m3u8.Segment):
+            nonlocal counter
+            url = urljoin(segment.base_uri, segment.uri)
+            fname = temp_folder / self._get_valid_pathname(segment.uri)
+            try:
+                res = self._session.get(str(url))
+                res.raise_for_status()
+
+                with fname.open("wb") as fout:
+                    fout.write(res.content)
+
+                counter += 1
+                self._progress_callback(counter / len(m3u8_content.segments) * 100)
+            except Exception as e:
+                # TODO: This gets ignored, because it's in a seperate thread...
+                raise DownloadError(
+                    f"Encountered this error while downloading: {str(e)}"
+                )
+
+        try:
+            with ThreadPoolExecutor(max_workers=12) as pool_video:
+                futures = [
+                    pool_video.submit(download_ts, s) for s in m3u8_content.segments
+                ]
+                try:
+                    for future in as_completed(futures):
+                        future.result()
+                except KeyboardInterrupt:
+                    self._info_callback(
+                        "Download Interrupted, cancelling futures, this may take a while..."
+                    )
+                    pool_video.shutdown(wait=False, cancel_futures=True)
+                    raise
+
+            self._info_callback("Parts Downloaded")
+
+            self._info_callback("Merging Parts...")
+            with download_path.open("wb") as merged:
+                for segment in m3u8_content.segments:
+                    fname = temp_folder / self._get_valid_pathname(segment.uri)
+                    if not fname.is_file():
+                        raise DownloadError(
+                            f"Could not merge, missing a segment of this playlist: {stream.url}"
+                        )
+
+                    with fname.open("rb") as mergefile:
+                        shutil.copyfileobj(mergefile, merged)
+
+            self._info_callback("Merge Finished")
+            shutil.rmtree(temp_folder)
+
+            return download_path
+        except KeyboardInterrupt:
+            self._info_callback("Download Interrupted, deleting partial file.")
+            download_path.unlink(missing_ok=True)
+            shutil.rmtree(temp_folder)
+            raise
+
+    def mp4_download(self, stream: "ProviderStream", download_path: Path) -> Path:
+        """Download a mp4 stream to a specified download path.
+
+        The suffix of the download path will be replaced (or added)
+        with ".mp4", use the path returned instead of the passed path.
+
+        Args:
+            stream: The mp4 stream
+            download_path: The path to download the stream to
+
+        Returns:
+            The download path with a ".mp4" suffix
+        """
+        r = self._session.get(stream.url, stream=True)
+        r.raise_for_status()
+        total = int(r.headers.get("content-length", 0))
+        try:
+            file_handle = download_path.with_suffix(".mp4").open("w")
+            for data in r.iter_content(chunk_size=1024):
+                size = file_handle.write(data)
+                self._progress_callback(size / total * 100)
+        except KeyboardInterrupt:
+            self._info_callback("Download Interrupted, deleting partial file.")
+            download_path.unlink()
+            raise
+
+        self._info_callback("Download finished.")
+
+        return download_path.with_suffix(".mp4")
+
+    def ffmpeg_download(self, stream: "ProviderStream", download_path: Path) -> Path:
+        """Download a stream with FFmpeg, FFmpeg needs to be installed on the
+        system. FFmpeg will be able to handle about any stream and it is also
+        able to remux the resulting video. By changing the suffix of the
+        `download_path` you are able to tell ffmpeg to remux to a specific
+        container.
+
+        Args:
+            stream: The stream
+            download_path: The path to download to including a specific suffix.
+
+        Returns:
+            The download path, this should be the same as the
+            passed one as ffmpeg will remux to about any container.
+        """
+        ffmpeg = FFmpeg(executable="ffprobe").input(
+            stream.url, print_format="json", show_format=None
+        )
+        meta = json.loads(ffmpeg.execute())
+        duration = float(meta["format"]["duration"])
+
+        ffmpeg = (
+            FFmpeg()
+            .option("y")
+            .option("v", "warning")
+            .option("stats")
+            .input(stream.url)
+            .output(
+                download_path,
+                {"c:v": "copy", "c:a": "copy", "c:s": "mov_text"},
+            )
+        )
+
+        @ffmpeg.on("progress")
+        def on_progress(progress: Progress):
+            self._progress_callback(progress.time.total_seconds() / duration * 100)
+
+        try:
+            ffmpeg.execute()
+        except KeyboardInterrupt:
+            self._info_callback("interrupted deleting partially downloaded file")
+            download_path.unlink()
+            raise
+
+        return download_path
+
+    def download(
+        self,
+        stream: "ProviderStream",
+        download_path: Path,
+        container: Optional[str] = None,
+        ffmpeg: bool = False,
+    ) -> Path:
+        """Generic download function that determines the best way to download a
+        specific stream and downloads it. The suffix should be omitted here,
+        you can instead use the `container` argument to remux the stream after
+        the download, note that this will trigger the `progress_callback`
+        again. This function assumes that ffmpeg is installed on the system,
+        because if the stream is neither m3u8 or mp4 it will default to
+        [ffmpeg_download][anipy_api.download.Downloader.ffmpeg_download].
+
+        Args:
+            stream: The stream to download
+            download_path: The path to download the stream to.
+            container: The container to remux the video to if it is not already
+                correctly muxed, the user must have ffmpeg installed on the system.
+                Containers may include all containers supported by FFmpeg e.g. ".mp4", ".mkv" etc...
+            ffmpeg: Wheter to automatically default to
+                [ffmpeg_download][anipy_api.download.Downloader.ffmpeg_download] for m3u8/hls streams.
+
+        Returns:
+            The path of the resulting file
+        """
+        download_path.parent.mkdir(parents=True, exist_ok=True)
+
+        for p in download_path.parent.iterdir():
+            if p.with_suffix("").name == download_path.name:
+                self._info_callback("Episode is already downloaded, skipping")
+                return p
+
+        if "m3u8" in stream.url:
+            if ffmpeg:
+                download_path = download_path.with_suffix(container or ".mp4")
+                self._info_callback("Using FFMPEG downloader")
+                self._info_callback(f"Saving to a {container or '.mp4'} container")
+                path = self.ffmpeg_download(stream, download_path)
+            else:
+                self._info_callback("Using internal M3U8 downloader")
+                path = self.m3u8_download(stream, download_path)
+        elif "mp4" in stream.url:
+            self._info_callback("Using internal MP4 downloader")
+            path = self.mp4_download(stream, download_path.with_suffix(".mp4"))
+        else:
+            self._info_callback(
+                "No fitting downloader available for stream, using FFMPEG downloader as fallback"
+            )
+            path = self.ffmpeg_download(stream, download_path)
+
+        if container:
+            if container == path.suffix:
+                return path
+            self._info_callback(f"Remuxing to {container} container")
+            new_path = path.with_suffix(container)
+            download = self.ffmpeg_download(
+                ProviderStream(
+                    str(path), stream.resolution, stream.episode, stream.language
+                ),
+                new_path,
+            )
+            path.unlink()
+            return download
+
+        return path

anipy_api-3.0.0/src/anipy_api/error.py

@@ -0,0 +1,93 @@
+from typing import Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from anipy_api.provider.base import LanguageTypeEnum
+
+
+class BeautifulSoupLocationError(Exception):
+    """Error that gets raised in the Provider if there are errors with parsing
+    HTML content."""
+
+    def __init__(self, what: str, where: str):
+        """__init__ for BeautifulSoupLocationError.
+
+        Args:
+            what: What could not be parsed
+            where: The url of the to be parsed content
+        """
+        super().__init__(f"Could not locate {what} at {where}")
+
+
+class LangTypeNotAvailableError(Exception):
+    """Error that gets raised in the Provider if the specified language type is
+    not available."""
+
+    def __init__(self, identifier: str, provider: str, lang: "LanguageTypeEnum"):
+        """__init__ for LangTypeNotAvailableError.
+
+        Args:
+            identifier: Identifier of the Anime
+            provider: Name of the Provider
+            lang: The language that is not available
+        """
+        super().__init__(
+            f"{str(lang).capitalize()} is not available for identifier `{identifier}` on provider `{provider}`"
+        )
+
+
+class MyAnimeListError(Exception):
+    """Error that gets raised by [MyAnimeList][anipy_api.mal.MyAnimeList], this
+    may include authentication errors or other HTTP errors."""
+
+    def __init__(
+        self, url: str, status: int, mal_api_error: Optional[Dict] = None
+    ) -> None:
+        """__init__ for MyAnimeListError.
+
+        Args:
+            url: Requested URL that caused the error
+            status: HTTP status code
+            mal_api_error: MyAnimeList api error if returned
+        """
+        error_text = f"Error requesting {url}, status is {status}."
+        if mal_api_error:
+            error_text = f"{error_text} Additional info from api {mal_api_error}"
+
+        super().__init__(error_text)
+
+
+class DownloadError(Exception):
+    """Error that gets raised by
+    [Downloader][anipy_api.download.Downloader]."""
+
+    def __init__(self, message: str):
+        """__init__ for DownloadError.
+
+        Args:
+            message: Failure reason
+        """
+        super().__init__(message)
+
+
+class PlayerError(Exception):
+    """Error that gets throws by certain functions in the player module."""
+
+    def __init__(self, message: str):
+        """__init__ for PlayerError.
+
+        Args:
+            message: Failure reason
+        """
+        super().__init__(message)
+
+
+class ArgumentError(Exception):
+    """Error that gets raised if something is wrong with the arguments provided to a callable."""
+
+    def __init__(self, message: str):
+        """__init__ for ArgumentError
+
+        Args:
+            message: Failure reason
+        """
+        super().__init__(message)