feat:switch to poetry as build tool and package manager

fastanime/cli/interfaces/stream_interface.py

@@ -0,0 +1,103 @@
+from ..utils.fzf import fzf
+from ...libs.anime_provider.allanime.api import anime_provider
+from ...Utility.data import anime_normalizer
+from ..utils.mpv import mpv
+from fuzzywuzzy import fuzz
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def back_(anime, options):
+    command = fzf(options.keys())
+    if command:
+        options[command](anime, options)
+
+
+def anime_title_percentage_match(
+    possible_user_requested_anime_title: str, title: tuple
+) -> float:
+    """Returns the percentage match between the possible title and user title
+
+    Args:
+        possible_user_requested_anime_title (str): an Animdl search result title
+        title (str): the anime title the user wants
+
+    Returns:
+        int: the percentage match
+    """
+    if normalized_anime_title := anime_normalizer.get(
+        possible_user_requested_anime_title
+    ):
+        possible_user_requested_anime_title = normalized_anime_title
+    for key, value in locals().items():
+        logger.info(f"{key}: {value}")
+    # compares both the romaji and english names and gets highest Score
+    percentage_ratio = max(
+        fuzz.ratio(title[0].lower(), possible_user_requested_anime_title.lower()),
+        fuzz.ratio(title[1].lower(), possible_user_requested_anime_title.lower()),
+    )
+    return percentage_ratio
+
+
+def get_matched_result(anime_title, _search_results):
+    result = max(
+        _search_results,
+        key=lambda x: anime_title_percentage_match(x, anime_title),
+    )
+
+    return result
+
+
+def _get_result(result, compare):
+    return result["name"] == compare
+
+
+def _get_server(server, server_name):
+    return server[0] == server_name
+
+
+def stream_interface(_anime, back, prefered_translation="sub"):
+    results = anime_provider.search_for_anime(_anime["title"]["romaji"])
+    if results:
+        _search_results = [result["name"] for result in results["shows"]["edges"]]
+
+        anime_title = get_matched_result(
+            (_anime["title"]["romaji"], _anime["title"]["english"]), _search_results
+        )
+        result = list(
+            filter(lambda x: _get_result(x, anime_title), results["shows"]["edges"])
+        )
+        if not result:
+            return
+
+        anime = anime_provider.get_anime(result[0]["_id"])
+        episode = fzf(anime["show"]["availableEpisodesDetail"][prefered_translation])
+
+        if not episode:
+            return
+        if t_type := fzf(["sub", "dub"]):
+            prefered_translation = t_type
+        _episode_streams = anime_provider.get_anime_episode(
+            result[0]["_id"], episode, prefered_translation
+        )
+        if _episode_streams:
+            episode_streams = anime_provider.get_episode_streams(_episode_streams)
+            if not episode_streams:
+                return
+            servers = list(episode_streams)
+
+            _sever = fzf([server[0] for server in servers])
+            if not _sever:
+                return
+
+            server = list(filter(lambda x: _get_server(x, _sever), servers)).pop()
+
+            if not server:
+                return
+            #
+            stream_link = server[1]["links"][0]["link"]
+            mpv(stream_link)
+            #
+            # mpv_player.run_mpv(stream_link)
+            stream_interface(_anime, back, prefered_translation)