feat: add awesome completions to search command

README.md

@@ -51,7 +51,6 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
       - [Key Bindings](#key-bindings)
       - [Script Messages](#script-messages)
   - [Configuration](#configuration)
-  - [The python api](#the-python-api)
   - [Contributing](#contributing)
   - [Receiving Support](#receiving-support)
   - [Supporting the Project](#supporting-the-project)
@@ -59,7 +58,7 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
 
 > [!IMPORTANT]
 >
-> This project currently scrapes allanime and animepahe. The site is in the public domain and can be accessed by any one with a browser.
+> This project currently scrapes allanime, aniwatch and animepahe. The site is in the public domain and can be accessed by any one with a browser.
 
 ## Installation
 
@@ -234,6 +233,7 @@ Available options for the fastanime include:
 - `--use-mpv-mod/--use-default-player` whether to use python-mpv
 - `--provider <allanime/animepahe>` anime site of choice to scrape from
 - `--sync-play` or `-sp` use syncplay for streaming anime so you can watch with your friends
+- `--sub_lang <en/or any other common shortform for country>` regex is used to determine the appropriate. Only works when provider is aniwatch.
 
 Example usage of the above options
 
@@ -267,6 +267,7 @@ Run `fastanime anilist` to access the main interface.
 ##### Subcommands
 
 The subcommands are mainly their as convenience. Since all the features already exist in the main interface.
+Most of the subcommands share the common option `--dump-json` or `-d` which will print only the json data and supress the ui.
 
 - `fastanime anilist trending`: Top 15 trending anime.
 - `fastanime anilist recent`: Top 15 recently updated anime.
@@ -276,6 +277,28 @@ The subcommands are mainly their as convenience. Since all the features already
 - `fastanime anilist favourites`: Top 15 favorite anime.
 - `fastanime anilist random`: get random anime
 
+**FastAnime Anilist Search subcommand**
+
+It is by far one of the most powerful commands.
+It offers the following options:
+
+- `--sort <MediaSort>` or `-s <MediaSort>`
+- `--title <anime-title>` or `-t <anime-title>`
+- `--tags <tag>` or `-t <tag>` can be specified multiple times for different tags to filter by.
+- `--year <year>` or `-y <year>`
+- `--status <MediaStatus>` or `-S <MediaStatus>`
+- `--media-format <MediaFormat>` or `-f <MediaFormat>`
+- `--season <MediaSeason>`
+- `--genres <genre>` or `-g <genre>` can be specified multiple times.
+
+Example:
+
+```bash
+fastanime anilist search -t isekai
+```
+
+For more details visit the anilist docs or just get the completions which will improve the experience.
+
 The following are commands you can only run if you are signed in to your AniList account:
 
 - `fastanime anilist watching`
@@ -362,6 +385,24 @@ fastanime download -t <anime-title> -r ':<episodes-end>'
 # remember python indexing starts at 0
 fastanime download -t <anime-title> -r '<episode-1>:<episode>'
 
+# merge subtitles with ffmpeg to mkv format; aniwatch tends to give subs as separate files
+# and dont prompt for anything
+# eg existing file in destination instead remove
+# and clean
+# ie remove original files (sub file and vid file)
+# only keep merged files
+fastanime download -t <anime-title> --merge --clean --no-prompt
+
+# EOF is used since -t always expects a title
+# you can supply anime titles from file or -t at the same time
+#
+# from stdin
+echo -e "<anime-title>\n<anime-title>\n<anime-title>" | fastanime download -t "EOF" -r <range> -f -
+
+# from file
+fastanime download -t "EOF" -r <range> -f <file-path>
+
+
 ```
 
 #### search subcommand
@@ -654,28 +695,6 @@ notification_duration=2
 # Not implemented yet
 ```
 
-## The python api
-
-The project offers a python api that can be used in other python programs.
-
-```python
-from fastanime.AnimeProvider import AnimeProvider
-
-# all output is typed, so will be easy to work with
-
-# providers include [allanime, animepahe]
-provider = AnimeProvider(provider="allanime")
-
-# to search for anime
-provider.search_for_anime()
-
-# to get anime info
-provider.get_anime()
-
-# to get streams of an episode
-provider.get_episode_streams()
-```
-
 ## Contributing
 
 We welcome your issues and feature requests. However, due to time constraints, we currently do not plan to add another provider.

fastanime/AnimeProvider.py

@@ -37,12 +37,12 @@ class AnimeProvider:
         self.provider = provider
         self.dynamic = dynamic
         self.retries = retries
-        self.lazyload_provider()
+        self.lazyload_provider(self.provider)
 
-    def lazyload_provider(self):
+    def lazyload_provider(self, provider):
         """updates the current provider being used"""
-        _, anime_provider_cls_name = anime_sources[self.provider].split(".", 1)
-        package = f"fastanime.libs.anime_provider.{self.provider}"
+        _, anime_provider_cls_name = anime_sources[provider].split(".", 1)
+        package = f"fastanime.libs.anime_provider.{provider}"
         provider_api = importlib.import_module(".api", package)
         anime_provider = getattr(provider_api, anime_provider_cls_name)
         self.anime_provider = anime_provider()
@@ -73,7 +73,7 @@ class AnimeProvider:
                 user_query, translation_type, nsfw, unknown
             )
         except Exception as e:
-            logging.error(e)
+            logger.error(e)
             results = None
         return results
 
@@ -95,7 +95,7 @@ class AnimeProvider:
         try:
             results = anime_provider.get_anime(anime_id)
         except Exception as e:
-            logging.error(e)
+            logger.error(e)
             results = None
         return results
 
@@ -123,6 +123,6 @@ class AnimeProvider:
                 anime, episode, translation_type
             )
         except Exception as e:
-            logging.error(e)
+            logger.error(e)
             results = None
         return results  # pyright:ignore

fastanime/Utility/downloader/downloader.py

@@ -1,8 +1,14 @@
 import logging
+import os
+import shutil
+import subprocess
+import tempfile
 from queue import Queue
 from threading import Thread
 
 import yt_dlp
+from rich import print
+from rich.prompt import Confirm
 from yt_dlp.utils import sanitize_filename
 
 logger = logging.getLogger(__name__)
@@ -38,6 +44,10 @@ class YtDLPDownloader:
         force_unknown_ext=False,
         verbose=False,
         headers={},
+        sub="",
+        merge=False,
+        clean=False,
+        prompt=True,
     ):
         """Helper function that downloads anime given url and path details
 
@@ -60,9 +70,85 @@ class YtDLPDownloader:
             "format": vid_format,
             "compat_opts": ("allow-unsafe-ext",) if force_unknown_ext else tuple(),
         }
+        urls = [url]
+        if sub:
+            urls.append(sub)
+        vid_path = ""
+        sub_path = ""
+        for i, url in enumerate(urls):
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=True)
+            if not info:
+                continue
+            if i == 0:
+                vid_path = info["requested_downloads"][0]["filepath"]
+            else:
+                sub_path = info["requested_downloads"][0]["filepath"]
+        if sub_path and vid_path and merge:
+            self.merge_subtitles(vid_path, sub_path, clean, prompt)
 
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([url])
+    def merge_subtitles(self, video_path, sub_path, clean, prompt):
+        # Extract the directory and filename
+        video_dir = os.path.dirname(video_path)
+        video_name = os.path.basename(video_path)
+        video_name, _ = os.path.splitext(video_name)
+        video_name += ".mkv"
+
+        FFMPEG_EXECUTABLE = shutil.which("ffmpeg")
+        if not FFMPEG_EXECUTABLE:
+            print("[yellow bold]WARNING: [/]FFmpeg not found")
+            return
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Temporary output path in the temporary directory
+            temp_output_path = os.path.join(temp_dir, video_name)
+            # FFmpeg command to merge subtitles
+            command = [
+                FFMPEG_EXECUTABLE,
+                "-hide_banner",
+                "-i",
+                video_path,
+                "-i",
+                sub_path,
+                "-c",
+                "copy",
+                "-map",
+                "0",
+                "-map",
+                "1",
+                temp_output_path,
+            ]
+
+            # Run the command
+            try:
+                subprocess.run(command, check=True)
+
+                # Move the file back to the original directory with the original name
+                final_output_path = os.path.join(video_dir, video_name)
+
+                if os.path.exists(final_output_path):
+                    if not prompt or Confirm.ask(
+                        f"File exists({final_output_path}) would you like to overwrite it",
+                        default=True,
+                    ):
+                        # move file to dest
+                        os.remove(final_output_path)
+                        shutil.move(temp_output_path, final_output_path)
+                else:
+                    shutil.move(temp_output_path, final_output_path)
+                # clean up
+                if clean:
+                    print("[cyan]Cleaning original files...[/]")
+                    os.remove(video_path)
+                    os.remove(sub_path)
+
+                print(
+                    f"[green bold]Subtitles merged successfully.[/] Output file: {final_output_path}"
+                )
+            except subprocess.CalledProcessError as e:
+                print(f"[red bold]Error[/] during merging subtitles: {e}")
+            except Exception as e:
+                print(f"[red bold]An error[/] occurred: {e}")
 
     # WARN: May remove this legacy functionality
     def download_file(self, url: str, title, silent=True):

fastanime/__init__.py

@@ -6,7 +6,7 @@ if sys.version_info < (3, 10):
     )  # noqa: F541
 
 
-__version__ = "v2.2.4"
+__version__ = "v2.3.8"
 
 APP_NAME = "FastAnime"
 AUTHOR = "Benex254"

fastanime/cli/__init__.py

@@ -98,6 +98,11 @@ signal.signal(signal.SIGINT, handle_exit)
     type=click.Choice(["dub", "sub"]),
     help="Anime language[dub/sub]",
 )
+@click.option(
+    "-sl",
+    "--sub-lang",
+    help="Set the preferred language for subs",
+)
 @click.option(
     "-A/-no-A",
     "--auto-next/--no-auto-next",
@@ -156,6 +161,7 @@ def run_cli(
     local_history,
     skip,
     translation_type,
+    sub_lang,
     quality,
     auto_next,
     auto_select,
@@ -186,7 +192,7 @@ def run_cli(
         FORMAT = "%(message)s"
 
         logging.basicConfig(
-            level="NOTSET", format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
+            level=logging.DEBUG, format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
         )
         logger = logging.getLogger(__name__)
         logger.info("logging has been initialized")
@@ -203,6 +209,10 @@ def run_cli(
             datefmt="[%d/%m/%Y@%H:%M:%S]",
             filemode="w",
         )
+    else:
+        import logging
+
+        logging.basicConfig(level=logging.CRITICAL)
     if rich_traceback:
         from rich.traceback import install
 
@@ -216,6 +226,8 @@ def run_cli(
         ctx.obj.server = server
     if format:
         ctx.obj.format = format
+    if sub_lang:
+        ctx.obj.sub_lang = sub_lang
     if ctx.get_parameter_source("continue_") == click.core.ParameterSource.COMMANDLINE:
         ctx.obj.continue_from_history = continue_
     if ctx.get_parameter_source("skip") == click.core.ParameterSource.COMMANDLINE:

fastanime/cli/app_updater.py

@@ -39,11 +39,11 @@ def check_for_updates():
                 and remote_tag[1] == local_tag[1]
             )
         ):
-            is_update = True
+            is_latest = False
         else:
-            is_update = False
+            is_latest = True
 
-        return (is_update, release_json)
+        return (is_latest, release_json)
     else:
         print(request.text)
         return (False, {})

fastanime/cli/commands/anilist/completed.py

@@ -7,16 +7,23 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you completed")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def completed(config: "Config"):
+def completed(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
+    from ...utils.tools import FastAnimeRuntimeState
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("COMPLETED")
     if not anime_list or not anime_list[1]:
         return
@@ -27,6 +34,13 @@ def completed(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    fastanime_runtime_state = FastAnimeRuntimeState()
-    fastanime_runtime_state.anilist_data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list))
+    else:
+        from ...interfaces import anilist_interfaces
+
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/dropped.py

@@ -7,26 +7,40 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you dropped")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def dropped(config: "Config"):
+def dropped(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("DROPPED")
     if not anime_list:
-        return
+        exit(1)
     if not anime_list[0] or not anime_list[1]:
-        return
+        exit(1)
     media = [
         mediaListItem["media"]
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    fastanime_runtime_state = FastAnimeRuntimeState()
-    fastanime_runtime_state.anilist_data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list[1]))
+    else:
+        from ...interfaces import anilist_interfaces
+        from ...utils.tools import FastAnimeRuntimeState
+
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/favourites.py

@@ -5,14 +5,30 @@ import click
     help="Fetch the top 15 most favourited anime from anilist",
     short_help="View most favourited anime",
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def favourites(config):
+def favourites(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_favourite()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = anime_data[1]
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/login.py

@@ -11,11 +11,11 @@ if TYPE_CHECKING:
 @click.option("--erase", "-e", help="Erase your login details", is_flag=True)
 @click.pass_obj
 def login(config: "Config", status, erase):
+    from sys import exit
+
     from rich import print
     from rich.prompt import Confirm, Prompt
 
-    from ...utils.tools import exit_app
-
     if status:
         is_logged_in = True if config.user else False
         message = (
@@ -23,16 +23,16 @@ def login(config: "Config", status, erase):
         )
         print(message)
         print(config.user)
-        exit_app()
+        exit(0)
     elif erase:
         if Confirm.ask(
             "Are you sure you want to erase your login status", default=False
         ):
             config.update_user({})
             print("Success")
-            exit_app(0)
+            exit(0)
         else:
-            exit_app(1)
+            exit(1)
     else:
         from click import launch
 
@@ -41,7 +41,7 @@ def login(config: "Config", status, erase):
         if config.user:
             print("Already logged in :confused:")
             if not Confirm.ask("or would you like to reloggin", default=True):
-                exit_app()
+                exit(0)
         # ---- new loggin -----
         print(
             f"A browser session will be opened ( [link]{config.fastanime_anilist_app_login_url}[/link] )",
@@ -52,10 +52,10 @@ def login(config: "Config", status, erase):
         user = AniList.login_user(token)
         if not user:
             print("Sth went wrong", user)
-            exit_app()
+            exit(1)
             return
         user["token"] = token
         config.update_user(user)
         print("Successfully saved credentials")
         print(user)
-        exit_app()
+        exit(0)

fastanime/cli/commands/anilist/notifier.py

@@ -13,6 +13,7 @@ def notifier(config: "Config"):
     import logging
     import os
     import time
+    from sys import exit
 
     import requests
     from plyer import notification
@@ -30,7 +31,7 @@ def notifier(config: "Config"):
     if not config.user:
         print("Not Authenticated")
         print("Run the following to get started: fastanime anilist loggin")
-        return
+        exit(1)
     run = True
     # WARNING: Mess around with this value at your own risk
     timeout = 2  # time is in minutes

fastanime/cli/commands/anilist/paused.py

@@ -7,26 +7,40 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you paused on watching")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def paused(config: "Config"):
+def paused(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("PAUSED")
     if not anime_list:
-        return
+        exit(1)
     if not anime_list[0] or not anime_list[1]:
-        return
+        exit(1)
     media = [
         mediaListItem["media"]
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = FastAnimeRuntimeState()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, anilist_config)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list[1]))
+    else:
+        from ...interfaces import anilist_interfaces
+        from ...utils.tools import FastAnimeRuntimeState
+
+        anilist_config = FastAnimeRuntimeState()
+        anilist_config.data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, anilist_config)

fastanime/cli/commands/anilist/planning.py

@@ -7,26 +7,40 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you are planning on watching")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def planning(config: "Config"):
+def planning(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("PLANNING")
     if not anime_list:
-        return
+        exit(1)
     if not anime_list[0] or not anime_list[1]:
-        return
+        exit(1)
     media = [
         mediaListItem["media"]
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    fastanime_runtime_state = FastAnimeRuntimeState()
-    fastanime_runtime_state.anilist_data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list[1]))
+    else:
+        from ...interfaces import anilist_interfaces
+        from ...utils.tools import FastAnimeRuntimeState
+
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/popular.py

@@ -4,14 +4,30 @@ import click
 @click.command(
     help="Fetch the top 15 most popular anime", short_help="View most popular anime"
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def popular(config):
+def popular(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_popular()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = anime_data[1]
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/random_anime.py

@@ -5,23 +5,35 @@ import click
     help="Get random anime from anilist based on a range of anilist anime ids that are seected at random",
     short_help="View random anime",
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def random_anime(config):
+def random_anime(config, dump_json):
     import random
 
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
-    random_anime = range(1, 15000)
+    random_anime = range(1, 100000)
 
     random_anime = random.sample(random_anime, k=50)
 
     anime_data = AniList.search(id_in=list(random_anime))
 
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = anime_data[1]
+            anilist_results_menu(config, fastanime_runtime_state)
     else:
-        print(anime_data[1])
+        exit(1)

fastanime/cli/commands/anilist/recent.py

@@ -5,14 +5,30 @@ import click
     help="Fetch the 15 most recently updated anime from anilist that are currently releasing",
     short_help="View recently updated anime",
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def recent(config):
+def recent(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_recently_updated()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = anime_data[1]
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/rewatching.py

@@ -7,26 +7,40 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you are rewatching")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def rewatching(config: "Config"):
+def rewatching(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("REPEATING")
     if not anime_list:
-        return
+        exit(1)
     if not anime_list[0] or not anime_list[1]:
-        return
+        exit(1)
     media = [
         mediaListItem["media"]
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    fastanime_runtime_state = FastAnimeRuntimeState()
-    fastanime_runtime_state.anilist_data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list[1]))
+    else:
+        from ...interfaces import anilist_interfaces
+        from ...utils.tools import FastAnimeRuntimeState
+
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/scores.py

@@ -4,14 +4,30 @@ import click
 @click.command(
     help="Fetch the 15 most scored anime", short_help="View most scored anime"
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def scores(config):
+def scores(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_scored()
     if anime_data[0]:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.data = anime_data[1]
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(anime_data[1]))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.data = anime_data[1]
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/search.py

@@ -2,20 +2,555 @@ import click
 
 from ...completion_functions import anime_titles_shell_complete
 
+tags_available = {
+    "Cast": ["Polyamorous"],
+    "Cast / Main Cast": [
+        "Anti-Hero",
+        "Elderly Protagonist",
+        "Ensemble Cast",
+        "Estranged Family",
+        "Female Protagonist",
+        "Male Protagonist",
+        "Primarily Adult Cast",
+        "Primarily Animal Cast",
+        "Primarily Child Cast",
+        "Primarily Female Cast",
+        "Primarily Male Cast",
+        "Primarily Teen Cast",
+    ],
+    "Cast / Traits": [
+        "Age Regression",
+        "Agender",
+        "Aliens",
+        "Amnesia",
+        "Angels",
+        "Anthropomorphism",
+        "Aromantic",
+        "Arranged Marriage",
+        "Artificial Intelligence",
+        "Asexual",
+        "Butler",
+        "Centaur",
+        "Chimera",
+        "Chuunibyou",
+        "Clone",
+        "Cosplay",
+        "Cowboys",
+        "Crossdressing",
+        "Cyborg",
+        "Delinquents",
+        "Demons",
+        "Detective",
+        "Dinosaurs",
+        "Disability",
+        "Dissociative Identities",
+        "Dragons",
+        "Dullahan",
+        "Elf",
+        "Fairy",
+        "Femboy",
+        "Ghost",
+        "Goblin",
+        "Gods",
+        "Gyaru",
+        "Hikikomori",
+        "Homeless",
+        "Idol",
+        "Kemonomimi",
+        "Kuudere",
+        "Maids",
+        "Mermaid",
+        "Monster Boy",
+        "Monster Girl",
+        "Nekomimi",
+        "Ninja",
+        "Nudity",
+        "Nun",
+        "Office Lady",
+        "Oiran",
+        "Ojou-sama",
+        "Orphan",
+        "Pirates",
+        "Robots",
+        "Samurai",
+        "Shrine Maiden",
+        "Skeleton",
+        "Succubus",
+        "Tanned Skin",
+        "Teacher",
+        "Tomboy",
+        "Transgender",
+        "Tsundere",
+        "Twins",
+        "Vampire",
+        "Veterinarian",
+        "Vikings",
+        "Villainess",
+        "VTuber",
+        "Werewolf",
+        "Witch",
+        "Yandere",
+        "Zombie",
+    ],
+    "Demographic": ["Josei", "Kids", "Seinen", "Shoujo", "Shounen"],
+    "Setting": ["Matriarchy"],
+    "Setting / Scene": [
+        "Bar",
+        "Boarding School",
+        "Circus",
+        "Coastal",
+        "College",
+        "Desert",
+        "Dungeon",
+        "Foreign",
+        "Inn",
+        "Konbini",
+        "Natural Disaster",
+        "Office",
+        "Outdoor",
+        "Prison",
+        "Restaurant",
+        "Rural",
+        "School",
+        "School Club",
+        "Snowscape",
+        "Urban",
+        "Work",
+    ],
+    "Setting / Time": [
+        "Achronological Order",
+        "Anachronism",
+        "Ancient China",
+        "Dystopian",
+        "Historical",
+        "Time Skip",
+    ],
+    "Setting / Universe": [
+        "Afterlife",
+        "Alternate Universe",
+        "Augmented Reality",
+        "Omegaverse",
+        "Post-Apocalyptic",
+        "Space",
+        "Urban Fantasy",
+        "Virtual World",
+    ],
+    "Technical": [
+        "4-koma",
+        "Achromatic",
+        "Advertisement",
+        "Anthology",
+        "CGI",
+        "Episodic",
+        "Flash",
+        "Full CGI",
+        "Full Color",
+        "No Dialogue",
+        "Non-fiction",
+        "POV",
+        "Puppetry",
+        "Rotoscoping",
+        "Stop Motion",
+    ],
+    "Theme / Action": [
+        "Archery",
+        "Battle Royale",
+        "Espionage",
+        "Fugitive",
+        "Guns",
+        "Martial Arts",
+        "Spearplay",
+        "Swordplay",
+    ],
+    "Theme / Arts": [
+        "Acting",
+        "Calligraphy",
+        "Classic Literature",
+        "Drawing",
+        "Fashion",
+        "Food",
+        "Makeup",
+        "Photography",
+        "Rakugo",
+        "Writing",
+    ],
+    "Theme / Arts-Music": [
+        "Band",
+        "Classical Music",
+        "Dancing",
+        "Hip-hop Music",
+        "Jazz Music",
+        "Metal Music",
+        "Musical Theater",
+        "Rock Music",
+    ],
+    "Theme / Comedy": ["Parody", "Satire", "Slapstick", "Surreal Comedy"],
+    "Theme / Drama": [
+        "Bullying",
+        "Class Struggle",
+        "Coming of Age",
+        "Conspiracy",
+        "Eco-Horror",
+        "Fake Relationship",
+        "Kingdom Management",
+        "Rehabilitation",
+        "Revenge",
+        "Suicide",
+        "Tragedy",
+    ],
+    "Theme / Fantasy": [
+        "Alchemy",
+        "Body Swapping",
+        "Cultivation",
+        "Fairy Tale",
+        "Henshin",
+        "Isekai",
+        "Kaiju",
+        "Magic",
+        "Mythology",
+        "Necromancy",
+        "Shapeshifting",
+        "Steampunk",
+        "Super Power",
+        "Superhero",
+        "Wuxia",
+        "Youkai",
+    ],
+    "Theme / Game": ["Board Game", "E-Sports", "Video Games"],
+    "Theme / Game-Card & Board Game": [
+        "Card Battle",
+        "Go",
+        "Karuta",
+        "Mahjong",
+        "Poker",
+        "Shogi",
+    ],
+    "Theme / Game-Sport": [
+        "Acrobatics",
+        "Airsoft",
+        "American Football",
+        "Athletics",
+        "Badminton",
+        "Baseball",
+        "Basketball",
+        "Bowling",
+        "Boxing",
+        "Cheerleading",
+        "Cycling",
+        "Fencing",
+        "Fishing",
+        "Fitness",
+        "Football",
+        "Golf",
+        "Handball",
+        "Ice Skating",
+        "Judo",
+        "Lacrosse",
+        "Parkour",
+        "Rugby",
+        "Scuba Diving",
+        "Skateboarding",
+        "Sumo",
+        "Surfing",
+        "Swimming",
+        "Table Tennis",
+        "Tennis",
+        "Volleyball",
+        "Wrestling",
+    ],
+    "Theme / Other": [
+        "Adoption",
+        "Animals",
+        "Astronomy",
+        "Autobiographical",
+        "Biographical",
+        "Body Horror",
+        "Cannibalism",
+        "Chibi",
+        "Cosmic Horror",
+        "Crime",
+        "Crossover",
+        "Death Game",
+        "Denpa",
+        "Drugs",
+        "Economics",
+        "Educational",
+        "Environmental",
+        "Ero Guro",
+        "Filmmaking",
+        "Found Family",
+        "Gambling",
+        "Gender Bending",
+        "Gore",
+        "Language Barrier",
+        "LGBTQ+ Themes",
+        "Lost Civilization",
+        "Marriage",
+        "Medicine",
+        "Memory Manipulation",
+        "Meta",
+        "Mountaineering",
+        "Noir",
+        "Otaku Culture",
+        "Pandemic",
+        "Philosophy",
+        "Politics",
+        "Proxy Battle",
+        "Psychosexual",
+        "Reincarnation",
+        "Religion",
+        "Royal Affairs",
+        "Slavery",
+        "Software Development",
+        "Survival",
+        "Terrorism",
+        "Torture",
+        "Travel",
+        "War",
+    ],
+    "Theme / Other-Organisations": [
+        "Assassins",
+        "Criminal Organization",
+        "Cult",
+        "Firefighters",
+        "Gangs",
+        "Mafia",
+        "Military",
+        "Police",
+        "Triads",
+        "Yakuza",
+    ],
+    "Theme / Other-Vehicle": [
+        "Aviation",
+        "Cars",
+        "Mopeds",
+        "Motorcycles",
+        "Ships",
+        "Tanks",
+        "Trains",
+    ],
+    "Theme / Romance": [
+        "Age Gap",
+        "Bisexual",
+        "Boys' Love",
+        "Female Harem",
+        "Heterosexual",
+        "Love Triangle",
+        "Male Harem",
+        "Matchmaking",
+        "Mixed Gender Harem",
+        "Teens' Love",
+        "Unrequited Love",
+        "Yuri",
+    ],
+    "Theme / Sci Fi": [
+        "Cyberpunk",
+        "Space Opera",
+        "Time Loop",
+        "Time Manipulation",
+        "Tokusatsu",
+    ],
+    "Theme / Sci Fi-Mecha": ["Real Robot", "Super Robot"],
+    "Theme / Slice of Life": [
+        "Agriculture",
+        "Cute Boys Doing Cute Things",
+        "Cute Girls Doing Cute Things",
+        "Family Life",
+        "Horticulture",
+        "Iyashikei",
+        "Parenthood",
+    ],
+}
+tags_available_list = []
+for tag_category, tags_in_category in tags_available.items():
+    tags_available_list.extend(tags_in_category)
+
 
 @click.command(
     help="Search for anime using anilists api and get top ~50 results",
     short_help="Search for anime",
 )
-@click.argument("title", shell_complete=anime_titles_shell_complete)
+@click.option("--title", "-t", shell_complete=anime_titles_shell_complete)
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
+@click.option(
+    "--season",
+    help="The season the media was released",
+    type=click.Choice(["WINTER", "SPRING", "SUMMER", "FALL"]),
+)
+@click.option(
+    "--status",
+    "-S",
+    help="The media status of the anime",
+    type=click.Choice(
+        ["FINISHED", "RELEASING", "NOT_YET_RELEASED", "CANCELLED", "HIATUS"]
+    ),
+)
+@click.option(
+    "--sort",
+    "-s",
+    help="What to sort the search results on",
+    type=click.Choice(
+        [
+            "ID",
+            "ID_DESC",
+            "TITLE_ROMAJI",
+            "TITLE_ROMAJI_DESC",
+            "TITLE_ENGLISH",
+            "TITLE_ENGLISH_DESC",
+            "TITLE_NATIVE",
+            "TITLE_NATIVE_DESC",
+            "TYPE",
+            "TYPE_DESC",
+            "FORMAT",
+            "FORMAT_DESC",
+            "START_DATE",
+            "START_DATE_DESC",
+            "END_DATE",
+            "END_DATE_DESC",
+            "SCORE",
+            "SCORE_DESC",
+            "POPULARITY",
+            "POPULARITY_DESC",
+            "TRENDING",
+            "TRENDING_DESC",
+            "EPISODES",
+            "EPISODES_DESC",
+            "DURATION",
+            "DURATION_DESC",
+            "STATUS",
+            "STATUS_DESC",
+            "CHAPTERS",
+            "CHAPTERS_DESC",
+            "VOLUMES",
+            "VOLUMES_DESC",
+            "UPDATED_AT",
+            "UPDATED_AT_DESC",
+            "SEARCH_MATCH",
+            "FAVOURITES",
+            "FAVOURITES_DESC",
+        ]
+    ),
+)
+@click.option(
+    "--genres",
+    "-g",
+    multiple=True,
+    help="the genres to filter by",
+    type=click.Choice(
+        [
+            "Action",
+            "Adventure",
+            "Comedy",
+            "Drama",
+            "Ecchi",
+            "Fantasy",
+            "Horror",
+            "Mahou Shoujo",
+            "Mecha",
+            "Music",
+            "Mystery",
+            "Psychological",
+            "Romance",
+            "Sci-Fi",
+            "Slice of Life",
+            "Sports",
+            "Supernatural",
+            "Thriller",
+            "Hentai",
+        ]
+    ),
+)
+@click.option(
+    "--tags",
+    "-T",
+    multiple=True,
+    help="the tags to filter by",
+    type=click.Choice(tags_available_list),
+)
+@click.option(
+    "--media-format",
+    "-f",
+    multiple=True,
+    help="Media format",
+    type=click.Choice(
+        ["TV", "TV_SHORT", "MOVIE", "SPECIAL", "OVA", "MUSIC", "NOVEL", "ONE_SHOT"]
+    ),
+)
+@click.option(
+    "--year",
+    "-y",
+    type=click.Choice(
+        [
+            "2024",
+            "2023",
+            "2022",
+            "2021",
+            "2020",
+            "2019",
+            "2018",
+            "2017",
+            "2016",
+            "2015",
+            "2014",
+            "2013",
+            "2012",
+            "2011",
+            "2010",
+            "2009",
+            "2008",
+            "2007",
+            "2006",
+            "2005",
+            "2004",
+            "2000",
+            "1990",
+            "1980",
+            "1970",
+            "1960",
+            "1950",
+            "1940",
+            "1930",
+            "1920",
+            "1910",
+            "1900",
+        ]
+    ),
+    help="the year the media was released",
+)
 @click.pass_obj
-def search(config, title):
+def search(
+    config, title, dump_json, season, status, sort, genres, tags, media_format, year
+):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
-    success, search_results = AniList.search(title)
+    success, search_results = AniList.search(
+        query=title,
+        sort=sort,
+        status=status,
+        genre_in=list(genres),
+        season=season,
+        tag_in=list(tags),
+        seasonYear=year,
+        format_in=list(media_format),
+    )
     if success:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = search_results
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(search_results))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = search_results
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/trending.py

@@ -5,14 +5,30 @@ import click
     help="Fetch the top 15 anime that are currently trending",
     short_help="Trending anime 🔥🔥🔥",
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def trending(config):
+def trending(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     success, data = AniList.get_trending()
     if success:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = data
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(data))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = data
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/upcoming.py

@@ -4,14 +4,30 @@ import click
 @click.command(
     help="Fetch the 15 most anticipited anime", short_help="View upcoming anime"
 )
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def upcoming(config):
+def upcoming(config, dump_json):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import anilist_results_menu
-    from ...utils.tools import FastAnimeRuntimeState
 
     success, data = AniList.get_upcoming_anime()
     if success:
-        fastanime_runtime_state = FastAnimeRuntimeState()
-        fastanime_runtime_state.anilist_data = data
-        anilist_results_menu(config, fastanime_runtime_state)
+        if dump_json:
+            import json
+
+            print(json.dumps(data))
+        else:
+            from ...interfaces.anilist_interfaces import anilist_results_menu
+            from ...utils.tools import FastAnimeRuntimeState
+
+            fastanime_runtime_state = FastAnimeRuntimeState()
+            fastanime_runtime_state.anilist_data = data
+            anilist_results_menu(config, fastanime_runtime_state)
+    else:
+        from sys import exit
+
+        exit(1)

fastanime/cli/commands/anilist/watching.py

@@ -7,26 +7,40 @@ if TYPE_CHECKING:
 
 
 @click.command(help="View anime you are watching")
+@click.option(
+    "--dump-json",
+    "-d",
+    is_flag=True,
+    help="Only print out the results dont open anilist menu",
+)
 @click.pass_obj
-def watching(config: "Config"):
+def watching(config: "Config", dump_json):
+    from sys import exit
+
     from ....anilist import AniList
-    from ...interfaces import anilist_interfaces
-    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
         print("Please run: fastanime anilist loggin")
-        exit_app()
+        exit(1)
     anime_list = AniList.get_anime_list("CURRENT")
     if not anime_list:
-        return
+        exit(1)
     if not anime_list[0] or not anime_list[1]:
-        return
+        exit(1)
     media = [
         mediaListItem["media"]
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    fastanime_runtime_state = FastAnimeRuntimeState()
-    fastanime_runtime_state.anilist_data = anime_list[1]
-    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)
+    if dump_json:
+        import json
+
+        print(json.dumps(anime_list[1]))
+    else:
+        from ...interfaces import anilist_interfaces
+        from ...utils.tools import FastAnimeRuntimeState
+
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_list[1]
+        anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/download.py

@@ -1,4 +1,3 @@
-import time
 from typing import TYPE_CHECKING
 
 import click
@@ -28,8 +27,14 @@ if TYPE_CHECKING:
     help="A range of episodes to download (start-end)",
 )
 @click.option(
-    "--force-unknown-ext",
+    "--file",
     "-f",
+    type=click.File(),
+    help="A file to read from all anime to download",
+)
+@click.option(
+    "--force-unknown-ext",
+    "-F",
     help="This option forces yt-dlp to download extensions its not aware of",
     is_flag=True,
 )
@@ -41,15 +46,43 @@ if TYPE_CHECKING:
     default=True,
 )
 @click.option("--verbose", "-v", is_flag=True, help="Download verbosely (everywhere)")
+@click.option(
+    "--merge", "-m", is_flag=True, help="Merge the subfile with video using ffmpeg"
+)
+@click.option(
+    "--clean",
+    "-c",
+    is_flag=True,
+    help="After merging delete the original files",
+)
+@click.option(
+    "--wait-time",
+    "-w",
+    type=int,
+    help="The amount of time to wait after downloading is complete before the screen is completely cleared",
+    default=60,
+)
+@click.option(
+    "--prompt/--no-prompt",
+    help="Dont prompt for anything instead just do the best thing",
+    default=True,
+)
 @click.pass_obj
 def download(
     config: "Config",
-    anime_titles: list,
+    anime_titles: tuple,
     episode_range,
+    file,
     force_unknown_ext,
     silent,
     verbose,
+    merge,
+    clean,
+    wait_time,
+    prompt,
 ):
+    import time
+
     from rich import print
     from rich.progress import Progress
     from thefuzz import fuzz
@@ -59,15 +92,28 @@ def download(
     from ...libs.fzf import fzf
     from ...Utility.downloader.downloader import downloader
     from ..utils.tools import exit_app
-    from ..utils.utils import filter_by_quality, fuzzy_inquirer
+    from ..utils.utils import (
+        filter_by_quality,
+        fuzzy_inquirer,
+        move_preferred_subtitle_lang_to_top,
+    )
 
     anime_provider = AnimeProvider(config.provider)
 
     translation_type = config.translation_type
     download_dir = config.downloads_dir
+    if file:
+        contents = file.read()
+        anime_titles_from_file = tuple(
+            [title for title in contents.split("\n") if title]
+        )
+        file.close()
 
+        anime_titles = (*anime_titles_from_file, *anime_titles)
     print(f"[green bold]Queued:[/] {anime_titles}")
     for anime_title in anime_titles:
+        if anime_title == "EOF":
+            break
         print(f"[green bold]Now Downloading: [/] {anime_title}")
         # ---- search for anime ----
         with Progress() as progress:
@@ -79,10 +125,23 @@ def download(
             print("Search results failed")
             input("Enter to retry")
             download(
-                config, anime_title, episode_range, force_unknown_ext, silent, verbose
+                config,
+                anime_title,
+                episode_range,
+                file,
+                force_unknown_ext,
+                silent,
+                verbose,
+                merge,
+                clean,
+                wait_time,
+                prompt,
             )
             return
         search_results = search_results["results"]
+        if not search_results:
+            print("Nothing muches your search term")
+            continue
         search_results_ = {
             search_result["title"]: search_result for search_result in search_results
         }
@@ -112,7 +171,17 @@ def download(
             print("Sth went wring anime no found")
             input("Enter to continue...")
             download(
-                config, anime_title, episode_range, force_unknown_ext, silent, verbose
+                config,
+                anime_title,
+                episode_range,
+                file,
+                force_unknown_ext,
+                silent,
+                verbose,
+                merge,
+                clean,
+                wait_time,
+                prompt,
             )
             return
 
@@ -165,37 +234,12 @@ def download(
                 if config.server == "top":
                     with Progress() as progress:
                         progress.add_task("Fetching top server...", total=None)
-                        server = next(streams, None)
-                        if not server:
+                        server_name = next(streams, None)
+                        if not server_name:
                             print("Sth went wrong when fetching the server")
                             continue
-                    stream_link = filter_by_quality(config.quality, server["links"])
-                    if not stream_link:
-                        print("[yellow bold]WARNING:[/] No streams found")
-                        time.sleep(1)
-                        print("Continuing...")
-                        continue
-                    link = stream_link["link"]
-                    provider_headers = server["headers"]
-                    episode_title = server["episode_title"]
-                else:
-                    with Progress() as progress:
-                        progress.add_task("Fetching servers", total=None)
-                        # prompt for server selection
-                        servers = {server["server"]: server for server in streams}
-                    servers_names = list(servers.keys())
-                    if config.server in servers_names:
-                        server = config.server
-                    else:
-                        if config.use_fzf:
-                            server = fzf.run(servers_names, "Select an link: ")
-                        else:
-                            server = fuzzy_inquirer(
-                                servers_names,
-                                "Select link",
-                            )
                     stream_link = filter_by_quality(
-                        config.quality, servers[server]["links"]
+                        config.quality, server_name["links"]
                     )
                     if not stream_link:
                         print("[yellow bold]WARNING:[/] No streams found")
@@ -203,14 +247,45 @@ def download(
                         print("Continuing...")
                         continue
                     link = stream_link["link"]
-                    provider_headers = servers[server]["headers"]
+                    provider_headers = server_name["headers"]
+                    episode_title = server_name["episode_title"]
+                    subtitles = server_name["subtitles"]
+                else:
+                    with Progress() as progress:
+                        progress.add_task("Fetching servers", total=None)
+                        # prompt for server selection
+                        servers = {server["server"]: server for server in streams}
+                    servers_names = list(servers.keys())
+                    if config.server in servers_names:
+                        server_name = config.server
+                    else:
+                        if config.use_fzf:
+                            server_name = fzf.run(servers_names, "Select an link: ")
+                        else:
+                            server_name = fuzzy_inquirer(
+                                servers_names,
+                                "Select link",
+                            )
+                    stream_link = filter_by_quality(
+                        config.quality, servers[server_name]["links"]
+                    )
+                    if not stream_link:
+                        print("[yellow bold]WARNING:[/] No streams found")
+                        time.sleep(1)
+                        print("Continuing...")
+                        continue
+                    link = stream_link["link"]
+                    provider_headers = servers[server_name]["headers"]
 
-                    episode_title = servers[server]["episode_title"]
+                    subtitles = servers[server_name]["subtitles"]
+                    episode_title = servers[server_name]["episode_title"]
                 print(f"[purple]Now Downloading:[/] {search_result} Episode {episode}")
-
+                subtitles = move_preferred_subtitle_lang_to_top(
+                    subtitles, config.sub_lang
+                )
                 downloader._download_file(
                     link,
-                    anime["title"],
+                    search_result,
                     episode_title,
                     download_dir,
                     silent,
@@ -218,10 +293,15 @@ def download(
                     force_unknown_ext,
                     verbose,
                     headers=provider_headers,
+                    sub=subtitles[0]["url"] if subtitles else "",
+                    merge=merge,
+                    clean=clean,
+                    prompt=prompt,
                 )
             except Exception as e:
                 print(e)
                 time.sleep(1)
                 print("Continuing...")
     print("Done Downloading")
+    time.sleep(wait_time)
     exit_app()

fastanime/cli/commands/grab.py

@@ -76,6 +76,9 @@ def grab(
             continue
 
         search_results = search_results["results"]
+        if not search_results:
+            logger.error("no results for your search")
+            exit(1)
         search_results_ = {
             search_result["title"]: search_result for search_result in search_results
         }
@@ -88,13 +91,13 @@ def grab(
         anime = anime_provider.get_anime(search_results_[search_result]["id"])
         if not anime:
             exit(1)
-        episodes = sorted(
-            anime["availableEpisodesDetail"][config.translation_type], key=float
-        )
         if anime_info_only:
             # grab only the anime data skipping all lines after this
             grabbed_animes.append(anime)
             continue
+        episodes = sorted(
+            anime["availableEpisodesDetail"][config.translation_type], key=float
+        )
 
         # where the magic happens
         if episode_range:
@@ -145,9 +148,9 @@ def grab(
                 if episode_streams_only:
                     grabbed_anime[episode] = episode_streams
                 else:
-                    grabbed_anime["episodes_streams"][
+                    grabbed_anime["episodes_streams"][  # pyright:ignore
                         episode
-                    ] = episode_streams  # pyright:ignore
+                    ] = episode_streams
 
             except Exception as e:
                 logger.error(e)

fastanime/cli/commands/search.py

@@ -35,7 +35,11 @@ def search(config: Config, anime_titles: str, episode_range: str):
     from ...libs.rofi import Rofi
     from ..utils.mpv import run_mpv
     from ..utils.tools import exit_app
-    from ..utils.utils import filter_by_quality, fuzzy_inquirer
+    from ..utils.utils import (
+        filter_by_quality,
+        fuzzy_inquirer,
+        move_preferred_subtitle_lang_to_top,
+    )
 
     anime_provider = AnimeProvider(config.provider)
 
@@ -177,6 +181,7 @@ def search(config: Config, anime_titles: str, episode_range: str):
                         stream_anime()
                         return
                     link = stream_link["link"]
+                    subtitles = server["subtitles"]
                     stream_headers = server["headers"]
                     episode_title = server["episode_title"]
                 else:
@@ -207,15 +212,23 @@ def search(config: Config, anime_titles: str, episode_range: str):
                         return
                     link = stream_link["link"]
                     stream_headers = servers[server]["headers"]
+                    subtitles = servers[server]["subtitles"]
                     episode_title = servers[server]["episode_title"]
                 print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
 
+                subtitles = move_preferred_subtitle_lang_to_top(
+                    subtitles, config.sub_lang
+                )
                 if config.sync_play:
                     from ..utils.syncplay import SyncPlayer
 
-                    SyncPlayer(link, episode_title, headers=stream_headers)
+                    SyncPlayer(
+                        link, episode_title, headers=stream_headers, subtitles=subtitles
+                    )
                 else:
-                    run_mpv(link, episode_title, headers=stream_headers)
+                    run_mpv(
+                        link, episode_title, headers=stream_headers, subtitles=subtitles
+                    )
             except IndexError as e:
                 print(e)
                 input("Enter to continue")

fastanime/cli/commands/update.py

@@ -24,8 +24,8 @@ def update(
         console.print(body)
 
     if check:
-        is_update, github_release_data = check_for_updates()
-        if is_update:
+        is_latest, github_release_data = check_for_updates()
+        if not is_latest:
             print(
                 f"You are running an older version ({__version__}) of fastanime please update to get the latest features"
             )
@@ -36,3 +36,7 @@ def update(
     else:
         success, github_release_data = update_app()
         _print_release(github_release_data)
+        if success:
+            print("Successfully updated")
+        else:
+            print("failed to update")

fastanime/cli/completion_functions.py

@@ -10,8 +10,6 @@ query($query:String){
     Page(perPage:50){
         pageInfo{
             total
-            currentPage
-            hasNextPage
         }
         media(search:$query,type:ANIME){
             id
@@ -46,20 +44,6 @@ def get_anime_titles(query: str, variables: dict = {}):
         )
         anilist_data = response.json()
 
-        # ensuring you dont get blocked
-        if (
-            int(response.headers.get("X-RateLimit-Remaining", 0)) < 30
-            and not response.status_code == 500
-        ):
-            print("Warning you are exceeding the allowed number of calls per minute")
-            logger.warning(
-                "You are exceeding the allowed number of calls per minute for the AniList api enforcing timeout"
-            )
-            print("Forced timeout will now be initiated")
-            import time
-
-            print("sleeping...")
-            time.sleep(1 * 60)
         if response.status_code == 200:
             eng_titles = [
                 anime["title"]["english"]
@@ -80,4 +64,16 @@ def get_anime_titles(query: str, variables: dict = {}):
 
 
 def anime_titles_shell_complete(ctx, param, incomplete):
-    return [name for name in get_anime_titles(anime_title_query, {"query": incomplete})]
+    incomplete = incomplete.strip()
+    if not incomplete:
+        incomplete = None
+        variables = {}
+    else:
+        variables = {"query": incomplete}
+    return get_anime_titles(anime_title_query, variables)
+
+
+if __name__ == "__main__":
+    t = input("Enter title")
+    results = get_anime_titles(anime_title_query, {"query": t})
+    print(results)

fastanime/cli/config.py

@@ -96,6 +96,7 @@ class Config(object):
                 "rofi_theme_input": "",
                 "rofi_theme_confirm": "",
                 "ffmpegthumnailer_seek_time": "-1",
+                "sub_lang": "eng",
             }
         )
         self.configparser.add_section("stream")
@@ -109,6 +110,7 @@ class Config(object):
 
         # --- set config values from file or using defaults ---
         self.downloads_dir = self.get_downloads_dir()
+        self.sub_lang = self.get_sub_lang()
         self.provider = self.get_provider()
         self.use_fzf = self.get_use_fzf()
         self.use_rofi = self.get_use_rofi()
@@ -187,6 +189,9 @@ class Config(object):
     def get_preferred_language(self):
         return self.configparser.get("general", "preferred_language")
 
+    def get_sub_lang(self):
+        return self.configparser.get("general", "sub_lang")
+
     def get_downloads_dir(self):
         return self.configparser.get("general", "downloads_dir")
 

fastanime/cli/interfaces/anilist_interfaces.py

@@ -21,7 +21,11 @@ from ...Utility.data import anime_normalizer
 from ...Utility.utils import anime_title_percentage_match
 from ..utils.mpv import run_mpv
 from ..utils.tools import exit_app
-from ..utils.utils import filter_by_quality, fuzzy_inquirer
+from ..utils.utils import (
+    filter_by_quality,
+    fuzzy_inquirer,
+    move_preferred_subtitle_lang_to_top,
+)
 from .utils import aniskip
 
 if TYPE_CHECKING:
@@ -113,6 +117,9 @@ def media_player_controls(
                 current_episode_number,
             ):
                 custom_args.extend(args)
+        subtitles = move_preferred_subtitle_lang_to_top(
+            selected_server["subtitles"], config.sub_lang
+        )
         if config.sync_play:
             from ..utils.syncplay import SyncPlayer
 
@@ -120,29 +127,21 @@ def media_player_controls(
                 current_episode_stream_link,
                 selected_server["episode_title"],
                 headers=selected_server["headers"],
+                subtitles=subtitles,
             )
         elif config.use_mpv_mod:
             from ..utils.player import player
 
-            mpv = player.create_player(
+            player.create_player(
                 current_episode_stream_link,
                 config.anime_provider,
                 fastanime_runtime_state,
                 config,
                 selected_server["episode_title"],
+                start_time,
                 headers=selected_server["headers"],
+                subtitles=subtitles,
             )
-
-            # TODO: implement custom aniskip
-            if custom_args and None:
-                chapters_file = custom_args[0].split("=", 1)
-                script_opts = custom_args[1].split("=", 1)
-                mpv._set_property("chapters-file", chapters_file[1])
-                mpv._set_property("script-opts", script_opts[1])
-            if not start_time == "0":
-                mpv.start = start_time
-            mpv.wait_for_shutdown()
-            mpv.terminate()
             stop_time = player.last_stop_time
             total_time = player.last_total_time
         else:
@@ -152,6 +151,7 @@ def media_player_controls(
                 start_time=start_time,
                 custom_args=custom_args,
                 headers=selected_server["headers"],
+                subtitles=subtitles,
             )
 
         # either update the watch history to the next episode or current depending on progress
@@ -502,6 +502,8 @@ def provider_anime_episode_servers_menu(
     )
     if start_time != "0" and episode_in_history == current_episode_number:
         print("[green]Continuing from:[/] ", start_time)
+    else:
+        start_time = "0"
     custom_args = []
     if config.skip:
         if args := aniskip(
@@ -509,6 +511,9 @@ def provider_anime_episode_servers_menu(
             current_episode_number,
         ):
             custom_args.extend(args)
+    subtitles = move_preferred_subtitle_lang_to_top(
+        selected_server["subtitles"], config.sub_lang
+    )
     if config.sync_play:
         from ..utils.syncplay import SyncPlayer
 
@@ -516,29 +521,24 @@ def provider_anime_episode_servers_menu(
             current_stream_link,
             selected_server["episode_title"],
             headers=selected_server["headers"],
+            subtitles=subtitles,
         )
     elif config.use_mpv_mod:
         from ..utils.player import player
 
-        mpv = player.create_player(
+        if start_time == "0" and episode_in_history != current_episode_number:
+            start_time = "0"
+        player.create_player(
             current_stream_link,
             anime_provider,
             fastanime_runtime_state,
             config,
             selected_server["episode_title"],
+            start_time,
             headers=selected_server["headers"],
+            subtitles=subtitles,
         )
 
-        # TODO: implement custom aniskip intergration
-        if custom_args and None:
-            chapters_file = custom_args[0].split("=", 1)
-            script_opts = custom_args[1].split("=", 1)
-            mpv._set_property("chapters-file", chapters_file[1])
-            mpv._set_property("script-opts", script_opts[1])
-        if not start_time == "0" and episode_in_history == current_episode_number:
-            mpv.start = start_time
-        mpv.wait_for_shutdown()
-        mpv.terminate()
         stop_time = player.last_stop_time
         total_time = player.last_total_time
         current_episode_number = fastanime_runtime_state.provider_current_episode_number
@@ -551,6 +551,7 @@ def provider_anime_episode_servers_menu(
             start_time=start_time,
             custom_args=custom_args,
             headers=selected_server["headers"],
+            subtitles=subtitles,
         )
     print("Finished at: ", stop_time)
 
@@ -681,14 +682,14 @@ def provider_anime_episodes_menu(
     if current_episode_number == "Back":
         media_actions_menu(config, fastanime_runtime_state)
         return
-
-    # try to get the start time and if not found default to "0"
-    start_time = user_watch_history.get(str(anime_id_anilist), {}).get(
-        "start_time", "0"
-    )
-    config.update_watch_history(
-        anime_id_anilist, current_episode_number, start_time=start_time
-    )
+    #
+    # # try to get the start time and if not found default to "0"
+    # start_time = user_watch_history.get(str(anime_id_anilist), {}).get(
+    #     "start_time", "0"
+    # )
+    # config.update_watch_history(
+    #     anime_id_anilist, current_episode_number, start_time=start_time
+    # )
 
     # update runtime data
     fastanime_runtime_state.provider_available_episodes = total_episodes
@@ -936,7 +937,7 @@ def media_actions_menu(
             score = Rofi.ask("Enter Score", is_int=True)
             score = max(100, min(0, score))
         else:
-            score = inquirer.number(
+            score = inquirer.number(  # pyright:ignore
                 message="Enter the score:",
                 min_allowed=0,
                 max_allowed=100,
@@ -1009,6 +1010,42 @@ def media_actions_menu(
 
         media_actions_menu(config, fastanime_runtime_state)
 
+    def _change_player(
+        config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"
+    ):
+        """Change the translation type to use
+
+        Args:
+            config: [TODO:description]
+            fastanime_runtime_state: [TODO:description]
+        """
+        # prompt for new translation type
+        options = ["syncplay", "mpv-mod", "default"]
+        if config.use_fzf:
+            player = fzf.run(
+                options,
+                prompt="Select Player:",
+            )
+        elif config.use_rofi:
+            player = Rofi.run(options, "Select Player: ")
+        else:
+            player = fuzzy_inquirer(
+                options,
+                "Select Player",
+            )
+
+        # update internal config
+        if player == "syncplay":
+            config.sync_play = True
+            config.use_mpv_mod = False
+        else:
+            config.sync_play = False
+            if player == "mpv-mod":
+                config.use_mpv_mod = True
+            else:
+                config.use_mpv_mod = False
+        media_actions_menu(config, fastanime_runtime_state)
+
     def _view_info(config: "Config", fastanime_runtime_state: "FastAnimeRuntimeState"):
         """helper function to view info of an anime from terminal
 
@@ -1122,7 +1159,9 @@ def media_actions_menu(
             config: [TODO:description]
             fastanime_runtime_state: [TODO:description]
         """
-        options = ["allanime", "animepahe"]
+        from ...libs.anime_provider import anime_sources
+
+        options = list(anime_sources.keys())
         if config.use_fzf:
             provider = fzf.run(
                 options, prompt="Select Translation Type:", header="Language Options"
@@ -1137,7 +1176,7 @@ def media_actions_menu(
 
         config.provider = provider
         config.anime_provider.provider = provider
-        config.anime_provider.lazyload_provider()
+        config.anime_provider.lazyload_provider(provider)
 
         media_actions_menu(config, fastanime_runtime_state)
 
@@ -1175,6 +1214,7 @@ def media_actions_menu(
         f"{'📖 ' if icons else ''}View Info": _view_info,
         f"{'🎧 ' if icons else ''}Change Translation Type": _change_translation_type,
         f"{'💽 ' if icons else ''}Change Provider": _change_provider,
+        f"{'💽 ' if icons else ''}Change Player": _change_player,
         f"{'🔘 ' if icons else ''}Toggle auto select anime": _toggle_auto_select,  #  WARN: problematic if you choose an anime that doesnt match id
         f"{'💠 ' if icons else ''}Toggle auto next episode": _toggle_auto_next,
         f"{'🔘 ' if icons else ''}Toggle continue from history": _toggle_continue_from_history,
@@ -1427,6 +1467,9 @@ def fastanime_main_menu(
         else:
             config.load_config()
 
+        config.anime_provider.provider = config.provider
+        config.anime_provider.lazyload_provider(config.provider)
+
         fastanime_main_menu(config, fastanime_runtime_state)
 
     icons = config.icons

fastanime/cli/utils/mpv.py

@@ -55,6 +55,7 @@ def run_mpv(
     ytdl_format="",
     custom_args=[],
     headers={},
+    subtitles=[],
 ):
     # Determine if mpv is available
     MPV = shutil.which("mpv")
@@ -108,6 +109,8 @@ def run_mpv(
             for header_name, header_value in headers.items():
                 mpv_headers += f"{header_name}:{header_value},"
             mpv_args.append(mpv_headers)
+        for subtitle in subtitles:
+            mpv_args.append(f"--sub-file={subtitle['url']}")
         if start_time != "0":
             mpv_args.append(f"--start={start_time}")
         if title:

fastanime/cli/utils/player.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 import mpv
 
 from ...anilist import AniList
-from .utils import filter_by_quality
+from .utils import filter_by_quality, move_preferred_subtitle_lang_to_top
 
 if TYPE_CHECKING:
     from typing import Literal
@@ -22,6 +22,7 @@ def format_time(duration_in_secs: float):
 class MpvPlayer(object):
     anime_provider: "AnimeProvider"
     config: "Config"
+    subs = []
     mpv_player: "mpv.MPV"
     last_stop_time: str = "0"
     last_total_time: str = "0"
@@ -113,7 +114,7 @@ class MpvPlayer(object):
         )
         if not episode_streams:
             self.mpv_player.show_text("No streams were found")
-            return None
+            return
 
         # always select the first
         if server == "top":
@@ -131,7 +132,7 @@ class MpvPlayer(object):
                 self.mpv_player.show_text(
                     f"Invalid server!!; servers available are: {episode_streams_dict.keys()}",
                 )
-                return None
+                return
         self.current_media_title = selected_server["episode_title"]
         links = selected_server["links"]
 
@@ -142,6 +143,9 @@ class MpvPlayer(object):
         self.mpv_player._set_property("start", "0")
         stream_link = stream_link_["link"]
         fastanime_runtime_state.provider_current_episode_stream_link = stream_link
+        self.subs = move_preferred_subtitle_lang_to_top(
+            selected_server["subtitles"], config.sub_lang
+        )
         return stream_link
 
     def create_player(
@@ -151,8 +155,11 @@ class MpvPlayer(object):
         fastanime_runtime_state,
         config: "Config",
         title,
+        start_time,
         headers={},
+        subtitles=[],
     ):
+        self.subs = subtitles
         self.anime_provider = anime_provider
         self.fastanime_runtime_state = fastanime_runtime_state
         self.config = config
@@ -171,17 +178,6 @@ class MpvPlayer(object):
             osc=True,
             ytdl=True,
         )
-        mpv_player.force_window = config.force_window
-        # mpv_player.cache = "yes"
-        # mpv_player.cache_pause = "no"
-        mpv_player.title = title
-        mpv_headers = ""
-        if headers:
-            for header_name, header_value in headers.items():
-                mpv_headers += f"{header_name}:{header_value},"
-        mpv_player.http_header_fields = mpv_headers
-
-        mpv_player.play(stream_link)
 
         # -- events --
         @mpv_player.event_callback("file-loaded")
@@ -190,6 +186,22 @@ class MpvPlayer(object):
             self.player_fetching = False
             if isinstance(d, float):
                 self.last_total_time = format_time(d)
+            try:
+                if not mpv_player.core_shutdown:
+                    if self.subs:
+                        for i, subtitle in enumerate(self.subs):
+                            if i == 0:
+                                flag = "select"
+                            else:
+                                flag = "auto"
+                            mpv_player.sub_add(
+                                subtitle["url"], flag, None, subtitle["language"]
+                            )
+                        self.subs = []
+            except mpv.ShutdownError:
+                pass
+            except Exception:
+                pass
 
         @mpv_player.property_observer("time-pos")
         def handle_time_start_update(*args):
@@ -218,7 +230,9 @@ class MpvPlayer(object):
         def _next_episode():
             url = self.get_episode("next")
             if url:
-                mpv_player.loadfile(url, options=f"title={self.current_media_title}")
+                mpv_player.loadfile(
+                    url,
+                )
                 mpv_player.title = self.current_media_title
 
         @mpv_player.on_key_press("shift+p")
@@ -327,7 +341,23 @@ class MpvPlayer(object):
         mpv_player.register_message_handler("select-quality", select_quality)
 
         self.mpv_player = mpv_player
-        return mpv_player
+        mpv_player.force_window = config.force_window
+        # mpv_player.cache = "yes"
+        # mpv_player.cache_pause = "no"
+        mpv_player.title = title
+        mpv_headers = ""
+        if headers:
+            for header_name, header_value in headers.items():
+                mpv_headers += f"{header_name}:{header_value},"
+        mpv_player.http_header_fields = mpv_headers
+
+        mpv_player.play(stream_link)
+
+        if not start_time == "0":
+            mpv_player.start = start_time
+
+        mpv_player.wait_for_shutdown()
+        mpv_player.terminate()
 
 
 player = MpvPlayer()

fastanime/cli/utils/syncplay.py

@@ -4,7 +4,7 @@ import subprocess
 from .tools import exit_app
 
 
-def SyncPlayer(url: str, anime_title=None, headers={}, *args):
+def SyncPlayer(url: str, anime_title=None, headers={}, subtitles=[], *args):
     # TODO: handle m3u8 multi quality streams
     #
     # check for SyncPlay
@@ -20,6 +20,8 @@ def SyncPlayer(url: str, anime_title=None, headers={}, *args):
         for header_name, header_value in headers.items():
             mpv_headers += f"{header_name}:{header_value},"
         mpv_args.append(mpv_headers)
+    for subtitle in subtitles:
+        mpv_args.append(f"--sub-file={subtitle['url']}")
     if not anime_title:
         subprocess.run(
             [

fastanime/cli/utils/tools.py

@@ -15,25 +15,14 @@ class FastAnimeRuntimeState(dict):
 
 
 def exit_app(exit_code=0, *args):
-    import os
-    import shutil
     import sys
 
+    from rich.console import Console
+
     from ...constants import APP_NAME, ICON_PATH, USER_NAME
 
-    def is_running_in_terminal():
-        try:
-            shutil.get_terminal_size()
-            return (
-                sys.stdin
-                and sys.stdin.isatty()
-                and sys.stdout.isatty()
-                and os.getenv("TERM") is not None
-            )
-        except OSError:
-            return False
-
-    if not is_running_in_terminal():
+    console = Console()
+    if not console.is_terminal:
         from plyer import notification
 
         notification.notify(
@@ -43,7 +32,6 @@ def exit_app(exit_code=0, *args):
             title="Shutting down",
         )  # pyright:ignore
     else:
-        from rich import print
-
-        print("Have a good day :smile:", USER_NAME)
+        console.clear()
+        console.print("Have a good day :smile:", USER_NAME)
     sys.exit(exit_code)

fastanime/cli/utils/utils.py

@@ -19,6 +19,46 @@ BG_GREEN = "\033[48;2;120;233;12;m"
 GREEN = "\033[38;2;45;24;45;m"
 
 
+def get_requested_quality_or_default_to_first(url, quality):
+    import yt_dlp
+
+    with yt_dlp.YoutubeDL({"quiet": True, "silent": True, "no_warnings": True}) as ydl:
+        m3u8_info = ydl.extract_info(url, False)
+        if not m3u8_info:
+            return
+
+    m3u8_formats = m3u8_info["formats"]
+    quality = int(quality)
+    quality_u = quality - 80
+    quality_l = quality + 80
+    for m3u8_format in m3u8_formats:
+        if m3u8_format["height"] == quality or (
+            m3u8_format["height"] < quality_u and m3u8_format["height"] > quality_l
+        ):
+            return m3u8_format["url"]
+    else:
+        return m3u8_formats[0]["url"]
+
+
+def move_preferred_subtitle_lang_to_top(sub_list, lang_str):
+    """Moves the dictionary with the given ID to the front of the list.
+
+    Args:
+      sub_list: list of subs
+      lang_str: the sub lang pref
+
+    Returns:
+      The modified list.
+    """
+    import re
+
+    for i, d in enumerate(sub_list):
+        if re.search(lang_str, d["language"], re.IGNORECASE):
+            sub_list.insert(0, sub_list.pop(i))
+            break
+    return sub_list
+
+
 def filter_by_quality(quality: str, stream_links: "list[EpisodeStream]", default=True):
     """Helper function used to filter a list of EpisodeStream objects to one that has a corresponding quality
 
@@ -106,7 +146,7 @@ def fuzzy_inquirer(choices: list, prompt: str, **kwargs):
     from click import clear
 
     clear()
-    action = inquirer.fuzzy(
+    action = inquirer.fuzzy(  # pyright:ignore
         prompt,
         choices,
         height="100%",

fastanime/constants.py

@@ -3,7 +3,9 @@ import sys
 from pathlib import Path
 from platform import system
 
-from . import APP_NAME, AUTHOR, __version__
+import click
+
+from . import APP_NAME, __version__
 
 PLATFORM = system()
 
@@ -17,19 +19,20 @@ if PLATFORM == "Windows":
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.ico")
 else:
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.png")
-PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
+# PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
 
 
 # ----- user configs and data -----
 
 S_PLATFORM = sys.platform
+APP_DATA_DIR = click.get_app_dir(APP_NAME)
 if S_PLATFORM == "win32":
     # app data
-    app_data_dir_base = os.getenv("LOCALAPPDATA")
-    if not app_data_dir_base:
-        raise RuntimeError("Could not determine app data dir please report to devs")
-    APP_DATA_DIR = os.path.join(app_data_dir_base, AUTHOR, APP_NAME)
-
+    # app_data_dir_base = os.getenv("LOCALAPPDATA")
+    # if not app_data_dir_base:
+    #     raise RuntimeError("Could not determine app data dir please report to devs")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, AUTHOR, APP_NAME)
+    #
     # cache dir
     APP_CACHE_DIR = os.path.join(APP_DATA_DIR, "cache")
 
@@ -39,9 +42,9 @@ if S_PLATFORM == "win32":
 
 elif S_PLATFORM == "darwin":
     # app data
-    app_data_dir_base = os.path.expanduser("~/Library/Application Support")
-    APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME, __version__)
-
+    # app_data_dir_base = os.path.expanduser("~/Library/Application Support")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME, __version__)
+    #
     # cache dir
     cache_dir_base = os.path.expanduser("~/Library/Caches")
     APP_CACHE_DIR = os.path.join(cache_dir_base, APP_NAME, __version__)
@@ -50,12 +53,12 @@ elif S_PLATFORM == "darwin":
     video_dir_base = os.path.expanduser("~/Movies")
     USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
 else:
-    # app data
-    app_data_dir_base = os.environ.get("XDG_CONFIG_HOME", "")
-    if not app_data_dir_base.strip():
-        app_data_dir_base = os.path.expanduser("~/.config")
-    APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME)
-
+    # # app data
+    # app_data_dir_base = os.environ.get("XDG_CONFIG_HOME", "")
+    # if not app_data_dir_base.strip():
+    #     app_data_dir_base = os.path.expanduser("~/.config")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME)
+    #
     # cache dir
     cache_dir_base = os.environ.get("XDG_CACHE_HOME", "")
     if not cache_dir_base.strip():

fastanime/libs/anilist/api.py

@@ -309,9 +309,13 @@ class AniListApi:
         status_not_in: list[str] | None = None,
         endDate_greater: int | None = None,
         endDate_lesser: int | None = None,
-        start_greater: int | None = None,
-        start_lesser: int | None = None,
+        startDate_greater: int | None = None,
+        startDate_lesser: int | None = None,
+        startDate: str | None = None,
+        seasonYear: str | None = None,
         page: int | None = None,
+        season: str | None = None,
+        format_in: list[str] | None = None,
         type="ANIME",
         **kwargs,
     ):
@@ -320,7 +324,7 @@ class AniListApi:
         """
         variables = {}
         for key, val in list(locals().items())[1:]:
-            if val is not None and key not in ["variables"]:
+            if val and key not in ["variables"]:
                 variables[key] = val
         search_results = self.get_data(search_query, variables=variables)
         return search_results

fastanime/libs/anilist/queries_graphql.py

@@ -221,11 +221,15 @@ $popularity_greater:Int,\
 $popularity_lesser:Int,\
 $averageScore_greater:Int,\
 $averageScore_lesser:Int,\
+$seasonYear:Int,\
 $startDate_greater:FuzzyDateInt,\
 $startDate_lesser:FuzzyDateInt,\
+$startDate:FuzzyDateInt,\
 $endDate_greater:FuzzyDateInt,\
 $endDate_lesser:FuzzyDateInt,\
+$format_in:[MediaFormat],\
 $type:MediaType\
+$season:MediaSeason\
 "
 # FuzzyDateInt = (yyyymmdd)
 # MediaStatus = (FINISHED,RELEASING,NOT_YET_RELEASED,CANCELLED,HIATUS)
@@ -247,6 +251,7 @@ query($query:String,%s){
       tag_not_in:$tag_not_in,
       status_in:$status_in,
       status:$status,
+    startDate:$startDate,
       status_not_in:$status_not_in,
       popularity_greater:$popularity_greater,
       popularity_lesser:$popularity_lesser,
@@ -256,7 +261,10 @@ query($query:String,%s){
       startDate_lesser:$startDate_lesser,
       endDate_greater:$endDate_greater,
       endDate_lesser:$endDate_lesser,
+    format_in:$format_in,
       sort:$sort,
+    season:$season,
+    seasonYear:$seasonYear,
       type:$type
       )
     {

fastanime/libs/anime_provider/__init__.py

@@ -1,13 +1,11 @@
+from .allanime.constants import SERVERS_AVAILABLE as ALLANIME_SERVERS
+from .animepahe.constants import SERVERS_AVAILABLE as ANIMEPAHESERVERS
+from .aniwatch.constants import SERVERS_AVAILABLE as ANIWATCHSERVERS
+
 anime_sources = {
     "allanime": "api.AllAnimeAPI",
     "animepahe": "api.AnimePaheApi",
+    "aniwatch": "api.AniWatchApi",
+    "aniwave": "api.AniWaveApi",
 }
-SERVERS_AVAILABLE = [
-    "sharepoint",
-    "dropbox",
-    "gogoanime",
-    "weTransfer",
-    "wixmp",
-    "kwik",
-    "Yt",
-]
+SERVERS_AVAILABLE = [*ALLANIME_SERVERS, *ANIMEPAHESERVERS, *ANIWATCHSERVERS]

fastanime/libs/anime_provider/allanime/api.py

@@ -11,12 +11,7 @@ from requests.exceptions import Timeout
 
 from ...anime_provider.base_provider import AnimeProvider
 from ..utils import give_random_quality, one_digit_symmetric_xor
-from .constants import (
-    ALLANIME_API_ENDPOINT,
-    ALLANIME_BASE,
-    ALLANIME_REFERER,
-    USER_AGENT,
-)
+from .constants import ALLANIME_API_ENDPOINT, ALLANIME_BASE, ALLANIME_REFERER
 from .gql_queries import ALLANIME_EPISODES_GQL, ALLANIME_SEARCH_GQL, ALLANIME_SHOW_GQL
 
 if TYPE_CHECKING:
@@ -36,6 +31,9 @@ class AllAnimeAPI(AnimeProvider):
     """
 
     api_endpoint = ALLANIME_API_ENDPOINT
+    HEADERS = {
+        "Referer": ALLANIME_REFERER,
+    }
 
     def _fetch_gql(self, query: str, variables: dict):
         """main abstraction over all requests to the allanime api
@@ -54,7 +52,6 @@ class AllAnimeAPI(AnimeProvider):
                     "variables": json.dumps(variables),
                     "query": query,
                 },
-                headers={"Referer": ALLANIME_REFERER, "User-Agent": USER_AGENT},
                 timeout=10,
             )
             if response.status_code == 200:
@@ -231,6 +228,7 @@ class AllAnimeAPI(AnimeProvider):
                             "server": "Yt",
                             "episode_title": f'{anime["title"]}; Episode {episode_number}',
                             "headers": {"Referer": f"https://{ALLANIME_BASE}/"},
+                            "subtitles": [],
                             "links": [
                                 {
                                     "link": url,
@@ -246,10 +244,6 @@ class AllAnimeAPI(AnimeProvider):
                     )
                     resp = self.session.get(
                         embed_url,
-                        headers={
-                            "Referer": ALLANIME_REFERER,
-                            "User-Agent": USER_AGENT,
-                        },
                         timeout=10,
                     )
 
@@ -260,6 +254,7 @@ class AllAnimeAPI(AnimeProvider):
                                 yield {
                                     "server": "gogoanime",
                                     "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
@@ -271,6 +266,7 @@ class AllAnimeAPI(AnimeProvider):
                                 yield {
                                     "server": "wetransfer",
                                     "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
@@ -282,6 +278,7 @@ class AllAnimeAPI(AnimeProvider):
                                 yield {
                                     "server": "sharepoint",
                                     "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
@@ -293,6 +290,7 @@ class AllAnimeAPI(AnimeProvider):
                                 yield {
                                     "server": "dropbox",
                                     "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
@@ -304,6 +302,7 @@ class AllAnimeAPI(AnimeProvider):
                                 yield {
                                     "server": "wixmp",
                                     "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
@@ -322,85 +321,3 @@ class AllAnimeAPI(AnimeProvider):
         except Exception as e:
             logger.error(f"FA(Allanime): {e}")
             return []
-
-
-if __name__ == "__main__":
-    anime_provider = AllAnimeAPI()
-    # lets see if it works :)
-    import subprocess
-    import sys
-
-    from InquirerPy import inquirer, validator  # pyright:ignore
-
-    anime = input("Enter the anime name: ")
-    translation = input("Enter the translation type: ")
-
-    search_results = anime_provider.search_for_anime(
-        anime, translation_type=translation.strip()
-    )
-
-    if not search_results:
-        raise Exception("No results found")
-
-    search_results = search_results["results"]
-    options = {show["title"]: show for show in search_results}
-    anime = inquirer.fuzzy(
-        "Enter the anime title",
-        list(options.keys()),
-        validate=validator.EmptyInputValidator(),
-    ).execute()
-    if anime is None:
-        print("No anime was selected")
-        sys.exit(1)
-
-    anime_result = options[anime]
-    anime_data = anime_provider.get_anime(anime_result["id"])
-    if not anime_data:
-        raise Exception("Anime not found")
-    availableEpisodesDetail = anime_data["availableEpisodesDetail"]
-    if not availableEpisodesDetail.get(translation.strip()):
-        raise Exception("No episodes found")
-
-    stream_link = True
-    while stream_link != "quit":
-        print("select episode")
-        episode = inquirer.fuzzy(
-            "Choose an episode",
-            availableEpisodesDetail[translation.strip()],
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if episode is None:
-            print("No episode was selected")
-            sys.exit(1)
-
-        if not anime_data:
-            print("Sth went wrong")
-            break
-        episode_streams_ = anime_provider.get_episode_streams(
-            anime_data,  # pyright: ignore
-            episode,
-            translation.strip(),
-        )
-        if episode_streams_ is None:
-            raise Exception("Episode not found")
-
-        episode_streams = list(episode_streams_)
-        stream_links = []
-        for server in episode_streams:
-            stream_links.extend([link["link"] for link in server["links"]])
-        stream_links.append("back")
-        stream_link = inquirer.fuzzy(
-            "Choose a link to stream",
-            stream_links,
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if stream_link == "quit":
-            print("Have a nice day")
-            sys.exit()
-        if not stream_link:
-            raise Exception("No stream was selected")
-
-        title = episode_streams[0].get(
-            "episode_title", "%s: Episode %s" % (anime_data["title"], episode)
-        )
-        subprocess.run(["mpv", f"--title={title}", stream_link])

fastanime/libs/anime_provider/allanime/constants.py

@@ -1,7 +1,4 @@
-from yt_dlp.utils.networking import random_user_agent
-
+SERVERS_AVAILABLE = ["sharepoint", "dropbox", "gogoanime", "weTransfer", "wixmp", "Yt"]
 ALLANIME_BASE = "allanime.day"
 ALLANIME_REFERER = "https://allanime.to/"
 ALLANIME_API_ENDPOINT = "https://api.{}/api/".format(ALLANIME_BASE)
-USER_AGENT = random_user_agent()
-SERVERS_AVAILABLE = ["sharepoint", "dropbox", "gogoanime", "weTransfer", "wixmp"]

fastanime/libs/anime_provider/animepahe/api.py

@@ -32,12 +32,14 @@ KWIK_RE = re.compile(r"Player\|(.+?)'")
 class AnimePaheApi(AnimeProvider):
     search_page: "AnimePaheSearchPage"
     anime: "AnimePaheAnimePage"
+    HEADERS = REQUEST_HEADERS
 
     def search_for_anime(self, user_query: str, *args):
         try:
             url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
-            headers = {**REQUEST_HEADERS}
-            response = self.session.get(url, headers=headers)
+            response = self.session.get(
+                url,
+            )
             if not response.status_code == 200:
                 return
             data: "AnimePaheSearchPage" = response.json()
@@ -85,7 +87,9 @@ class AnimePaheApi(AnimeProvider):
                 url,
                 page,
             ):
-                response = self.session.get(url, headers=REQUEST_HEADERS)
+                response = self.session.get(
+                    url,
+                )
                 if response.status_code == 200:
                     if not data:
                         data.update(response.json())
@@ -136,7 +140,7 @@ class AnimePaheApi(AnimeProvider):
                 },
                 "episodesInfo": [
                     {
-                        "title": episode["title"] or f"{title};{episode['episode']}",
+                        "title": f"{episode['title'] or title};{episode['episode']}",
                         "episode": episode["episode"],
                         "id": episode["session"],
                         "translation_type": episode["audio"],
@@ -171,7 +175,7 @@ class AnimePaheApi(AnimeProvider):
             anime_id = anime["id"]
             # fetch the episode page
             url = f"{ANIMEPAHE_BASE}/play/{anime_id}/{episode['session']}"
-            response = self.session.get(url, headers=REQUEST_HEADERS)
+            response = self.session.get(url)
             # get the element containing links to juicy streams
             c = get_element_by_id("resolutionMenu", response.text)
             resolutionMenuItems = get_elements_html_by_class("dropdown-item", c)
@@ -183,13 +187,14 @@ class AnimePaheApi(AnimeProvider):
 
             # get the episode title
             episode_title = (
-                f"{episode["title"] or anime['title']}; Episode {episode['episode']}"
+                f"{episode['title'] or anime['title']}; Episode {episode['episode']}"
             )
             # get all links
             streams = {
                 "server": "kwik",
                 "links": [],
                 "episode_title": episode_title,
+                "subtitles": [],
                 "headers": {},
             }
             for res_dict in res_dicts:
@@ -206,7 +211,11 @@ class AnimePaheApi(AnimeProvider):
                     )
                     return []
                 # get embed page
-                embed_response = self.session.get(embed_url, headers=SERVER_HEADERS)
+                embed_response = self.session.get(
+                    embed_url, headers={"User-Agent": self.USER_AGENT, **SERVER_HEADERS}
+                )
+                if not response.status_code == 200:
+                    continue
                 embed_page = embed_response.text
 
                 decoded_js = process_animepahe_embed_page(embed_page)

fastanime/libs/anime_provider/animepahe/constants.py

@@ -1,18 +1,14 @@
-from yt_dlp.utils.networking import random_user_agent
-
-USER_AGENT = random_user_agent()
 ANIMEPAHE = "animepahe.ru"
 ANIMEPAHE_BASE = f"https://{ANIMEPAHE}"
 ANIMEPAHE_ENDPOINT = f"{ANIMEPAHE_BASE}/api?"
 
+SERVERS_AVAILABLE = ["kwik"]
 REQUEST_HEADERS = {
     "Cookie": "__ddgid_=VvX0ebHrH2DsFZo4; __ddgmark_=3savRpSVFhvZcn5x; __ddg2_=buBJ3c4pNBYKFZNp; __ddg1_=rbVADKr9URtt55zoIGFa; SERVERID=janna; XSRF-TOKEN=eyJpdiI6IjV5bFNtd0phUHgvWGJxc25wL0VJSUE9PSIsInZhbHVlIjoicEJTZktlR2hxR2JZTWhnL0JzazlvZU5TQTR2bjBWZ2dDb0RwUXVUUWNSclhQWUhLRStYSmJmWmUxWkpiYkFRYU12RjFWejlSWHorME1wZG5qQ1U0TnFlNnBFR2laQjN1MjdyNjc5TjVPdXdJb2o5VkU1bEduRW9pRHNDTHh6Sy8iLCJtYWMiOiI0OTc0ZmNjY2UwMGJkOWY2MWNkM2NlMjk2ZGMyZGJmMWE0NTdjZTdkNGI2Y2IwNTIzZmFiZWU5ZTE2OTk0YmU4IiwidGFnIjoiIn0%3D; laravel_session=eyJpdiI6ImxvdlpqREFnTjdaeFJubUlXQWlJVWc9PSIsInZhbHVlIjoiQnE4R3VHdjZ4M1NDdEVWM1ZqMUxtNnVERnJCcmtCUHZKNzRPR2RFbzNFcStTL29xdnVTbWhsNVRBUXEybVZWNU1UYVlTazFqYlN5UjJva1k4czNGaXBTbkJJK01oTUd3VHRYVHBoc3dGUWxHYnFlS2NJVVNFbTFqMVBWdFpuVUgiLCJtYWMiOiI1NDdjZTVkYmNhNjUwZTMxZmRlZmVmMmRlMGNiYjAwYjlmYjFjY2U0MDc1YTQzZThiMTIxMjJlYTg1NTA4YjBmIiwidGFnIjoiIn0%3D; latest=5592 ",
     "Host": ANIMEPAHE,
-    "User-Agent": USER_AGENT,
     "Accept": "application , text/javascript, */*; q=0.01",
-    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Encoding": "Utf-8",
     "Referer": ANIMEPAHE_BASE,
-    "X-Requested-With": "XMLHttpRequest",
     "DNT": "1",
     "Connection": "keep-alive",
     "Sec-Fetch-Dest": "empty",
@@ -21,19 +17,17 @@ REQUEST_HEADERS = {
     "TE": "trailers",
 }
 SERVER_HEADERS = {
-    "User-Agent": USER_AGENT,
+    "Host": "kwik.si",
     "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8",
     "Accept-Language": "en-US,en;q=0.5",
-    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Encoding": "Utf-8",
     "DNT": "1",
-    "Alt-Used": "kwik.si",
     "Connection": "keep-alive",
-    "Referer": ANIMEPAHE_BASE,
-    "Cookie": "kwik_session=eyJpdiI6IlZ5UDd0c0lKTDB1NXlhTHZPeWxFc2c9PSIsInZhbHVlIjoieDJZbGhZUG1QZDNaeWtqR3lwWFNnREdhaHBxNVZRMWNDOHVucGpiMHRJOVdhVmpBc3lpTko1VExRMTFWcE1yUVJtVitoTWdOOU5ObTQ0Q0dHU0MzZU0yRUVvNmtWcUdmY3R4UWx4YklJTmpUL0ZodjhtVEpjWU96cEZoUUhUbVYiLCJtYWMiOiI2OGY2YThkOGU0MTgwOThmYzcyZThmNzFlZjlhMzQzMDgwNjlmMTc4NTIzMzc2YjE3YjNmMWQyNTk4NzczMmZiIiwidGFnIjoiIn0%3D; srv=s0; cf_clearance=QMoZtUpZrX0Mh4XJiFmFSSmoWndISPne5FcsGmKKvTQ-1723297585-1.0.1.1-6tVUnP.aef9XeNj0CnN.19D1el_r53t.lhqddX.J88gohH9UnsPWKeJ4yT0pTbcaGRbPuXTLOS.U72.wdy.gMg",
+    "Referer": "https://animepahe.ru/",
     "Upgrade-Insecure-Requests": "1",
     "Sec-Fetch-Dest": "iframe",
     "Sec-Fetch-Mode": "navigate",
     "Sec-Fetch-Site": "cross-site",
-    "Sec-Fetch-User": "?1",
     "Priority": "u=4",
+    "TE": "trailers",
 }

fastanime/libs/anime_provider/aniwatch/api.py

@@ -0,0 +1,236 @@
+import logging
+import re
+from html.parser import HTMLParser
+from itertools import cycle
+from urllib.parse import quote_plus
+
+from yt_dlp.utils import (
+    clean_html,
+    extract_attributes,
+    get_element_by_class,
+    get_element_html_by_class,
+    get_elements_by_class,
+    get_elements_html_by_class,
+)
+
+from ..base_provider import AnimeProvider
+from ..utils import give_random_quality
+from .constants import SERVERS_AVAILABLE
+from .types import AniWatchStream
+
+logger = logging.getLogger(__name__)
+
+LINK_TO_STREAMS_REGEX = re.compile(r".*://(.*)/embed-(2|4|6)/e-([0-9])/(.*)\?.*")
+IMAGE_HTML_ELEMENT_REGEX = re.compile(r"<img.*?>")
+
+
+class ParseAnchorAndImgTag(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.img_tag = None
+        self.a_tag = None
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "img":
+            self.img_tag = {attr[0]: attr[1] for attr in attrs}
+        if tag == "a":
+            self.a_tag = {attr[0]: attr[1] for attr in attrs}
+
+
+class AniWatchApi(AnimeProvider):
+    # HEADERS = {"Referer": "https://hianime.to/home"}
+
+    def search_for_anime(self, anime_title: str, *args):
+        try:
+            query = quote_plus(anime_title)
+            url = f"https://hianime.to/search?keyword={query}"
+            response = self.session.get(url)
+            if response.status_code != 200:
+                return
+            search_page = response.text
+            search_results_html_items = get_elements_by_class("flw-item", search_page)
+            results = []
+            for search_results_html_item in search_results_html_items:
+                film_poster_html = get_element_by_class(
+                    "film-poster", search_results_html_item
+                )
+
+                if not film_poster_html:
+                    continue
+                # get availableEpisodes
+                episodes_html = get_element_html_by_class("tick-sub", film_poster_html)
+                episodes = clean_html(episodes_html) or 12
+
+                # get anime id and poster image url
+                parser = ParseAnchorAndImgTag()
+                parser.feed(film_poster_html)
+                image_data = parser.img_tag
+                anime_link_data = parser.a_tag
+                if not image_data or not anime_link_data:
+                    continue
+
+                episodes = int(episodes)
+
+                # finally!!
+                image_link = image_data["data-src"]
+                anime_id = anime_link_data["data-id"]
+                title = anime_link_data["title"]
+
+                results.append(
+                    {
+                        "availableEpisodes": list(range(1, episodes)),
+                        "id": anime_id,
+                        "title": title,
+                        "poster": image_link,
+                    }
+                )
+            self.search_results = results
+            return {"pageInfo": {}, "results": results}
+
+        except Exception as e:
+            logger.error(e)
+
+    def get_anime(self, aniwatch_id, *args):
+        try:
+            anime_result = {}
+            for anime in self.search_results:
+                if anime["id"] == aniwatch_id:
+                    anime_result = anime
+                    break
+            anime_url = f"https://hianime.to/ajax/v2/episode/list/{aniwatch_id}"
+            response = self.session.get(anime_url, timeout=10)
+            if response.status_code == 200:
+                response_json = response.json()
+                aniwatch_anime_page = response_json["html"]
+                episodes_info_container_html = get_element_html_by_class(
+                    "ss-list", aniwatch_anime_page
+                )
+                episodes_info_html_list = get_elements_html_by_class(
+                    "ep-item", episodes_info_container_html
+                )
+                # keys: [ data-number: episode_number, data-id: episode_id, title: episode_title , href:episode_page_url]
+                episodes_info_dicts = [
+                    extract_attributes(episode_dict)
+                    for episode_dict in episodes_info_html_list
+                ]
+                episodes = [episode["data-number"] for episode in episodes_info_dicts]
+                self.episodes_info = [
+                    {
+                        "id": episode["data-id"],
+                        "title": (
+                            (episode["title"] or "").replace(
+                                f"Episode {episode['data-number']}", ""
+                            )
+                            or anime_result["title"]
+                        )
+                        + f"; Episode {episode['data-number']}",
+                        "episode": episode["data-number"],
+                    }
+                    for episode in episodes_info_dicts
+                ]
+                return {
+                    "id": aniwatch_id,
+                    "availableEpisodesDetail": {
+                        "dub": episodes,
+                        "sub": episodes,
+                        "raw": episodes,
+                    },
+                    "poster": anime_result["poster"],
+                    "title": anime_result["title"],
+                    "episodes_info": self.episodes_info,
+                }
+        except Exception as e:
+            logger.error(e)
+
+    def get_episode_streams(self, anime, episode, translation_type, *args):
+        try:
+            episode_details = [
+                episode_details
+                for episode_details in self.episodes_info
+                if episode_details["episode"] == episode
+            ]
+            if not episode_details:
+                return
+            episode_details = episode_details[0]
+            episode_url = f"https://hianime.to/ajax/v2/episode/servers?episodeId={episode_details['id']}"
+            response = self.session.get(episode_url)
+            if response.status_code == 200:
+                response_json = response.json()
+                episode_page_html = response_json["html"]
+                servers_containers_html = get_elements_html_by_class(
+                    "ps__-list", episode_page_html
+                )
+                if not servers_containers_html:
+                    return
+                # sub servers
+                try:
+                    servers_html_sub = get_elements_html_by_class(
+                        "server-item", servers_containers_html[0]
+                    )
+                except Exception:
+                    logger.warn("AniWatch: sub not found")
+                    servers_html_sub = None
+
+                # dub servers
+                try:
+                    servers_html_dub = get_elements_html_by_class(
+                        "server-item", servers_containers_html[1]
+                    )
+                except Exception:
+                    logger.warn("AniWatch: dub not found")
+                    servers_html_dub = None
+
+                if translation_type == "dub":
+                    servers_html = servers_html_dub
+                else:
+                    servers_html = servers_html_sub
+                if not servers_html:
+                    return
+                for server_name, server_html in zip(
+                    cycle(SERVERS_AVAILABLE), servers_html
+                ):
+                    try:
+                        # keys: [ data-type: translation_type, data-id: embed_id, data-server-id: server_id ]
+                        servers_info = extract_attributes(server_html)
+                        embed_url = f"https://hianime.to/ajax/v2/episode/sources?id={servers_info['data-id']}"
+                        embed_response = self.session.get(embed_url)
+                        if embed_response.status_code == 200:
+                            embed_json = embed_response.json()
+                            raw_link_to_streams = embed_json["link"]
+                            match = LINK_TO_STREAMS_REGEX.match(raw_link_to_streams)
+                            if not match:
+                                continue
+                            provider_domain = match.group(1)
+                            embed_type = match.group(2)
+                            episode_number = match.group(3)
+                            source_id = match.group(4)
+
+                            link_to_streams = f"https://{provider_domain}/embed-{embed_type}/ajax/e-{episode_number}/getSources?id={source_id}"
+                            link_to_streams_response = self.session.get(link_to_streams)
+                            if link_to_streams_response.status_code == 200:
+                                juicy_streams_json: "AniWatchStream" = (
+                                    link_to_streams_response.json()
+                                )
+                                yield {
+                                    "headers": {},
+                                    "subtitles": [
+                                        {
+                                            "url": track["file"],
+                                            "language": track["label"],
+                                        }
+                                        for track in juicy_streams_json["tracks"]
+                                        if track["kind"] == "captions"
+                                    ],
+                                    "server": server_name,
+                                    "episode_title": episode_details["title"],
+                                    "links": give_random_quality(
+                                        [
+                                            {"link": link["file"], "type": link["type"]}
+                                            for link in juicy_streams_json["sources"]
+                                        ]
+                                    ),
+                                }
+                    except Exception as e:
+                        logger.error(e)
+        except Exception as e:
+            logger.error(e)

fastanime/libs/anime_provider/aniwatch/constants.py

@@ -0,0 +1 @@
+SERVERS_AVAILABLE = ["HD1", "HD2", "StreamSB", "StreamTape"]

fastanime/libs/anime_provider/aniwatch/types.py

@@ -0,0 +1,26 @@
+from typing import Literal, TypedDict
+
+
+class AniWatchSkipTime(TypedDict):
+    start: int
+    end: int
+
+
+class AniWatchSource(TypedDict):
+    file: str
+    type: str
+
+
+class AniWatchTrack(TypedDict):
+    file: str
+    label: str
+    kind: Literal["captions", "thumbnails", "audio"]
+
+
+class AniWatchStream(TypedDict):
+    sources: list[AniWatchSource]
+    tracks: list[AniWatchTrack]
+    encrypted: bool
+    intro: AniWatchSkipTime
+    outro: AniWatchSkipTime
+    server: int

fastanime/libs/anime_provider/aniwave/api.py

@@ -0,0 +1,65 @@
+from html.parser import HTMLParser
+
+from yt_dlp.utils import clean_html, get_element_by_class, get_elements_by_class
+
+from ..base_provider import AnimeProvider
+from .constants import ANIWAVE_BASE, SEARCH_HEADERS
+
+
+class ParseAnchorAndImgTag(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.img_tag = None
+        self.a_tag = None
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "img":
+            self.img_tag = {attr[0]: attr[1] for attr in attrs}
+        if tag == "a":
+            self.a_tag = {attr[0]: attr[1] for attr in attrs}
+
+
+class AniWaveApi(AnimeProvider):
+    def search_for_anime(self, anime_title, *args):
+        self.session.headers.update(SEARCH_HEADERS)
+        search_url = f"{ANIWAVE_BASE}/filter"
+        params = {"keyword": anime_title}
+        res = self.session.get(search_url, params=params)
+        search_page = res.text
+        search_results_html_list = get_elements_by_class("item", search_page)
+        results = []
+        for result_html in search_results_html_list:
+            aniposter_html = get_element_by_class("poster", result_html)
+            episode_html = get_element_by_class("sub", aniposter_html)
+            episodes = clean_html(episode_html) or 12
+            if not aniposter_html:
+                return
+            parser = ParseAnchorAndImgTag()
+            parser.feed(aniposter_html)
+            image_data = parser.img_tag
+            anime_link_data = parser.a_tag
+            if not image_data or not anime_link_data:
+                continue
+
+            episodes = int(episodes)
+
+            # finally!!
+            image_link = image_data["src"]
+            title = image_data["alt"]
+            anime_id = anime_link_data["href"]
+
+            results.append(
+                {
+                    "availableEpisodes": list(range(1, episodes)),
+                    "id": anime_id,
+                    "title": title,
+                    "poster": image_link,
+                }
+            )
+        self.search_results = results
+        return {"pageInfo": {}, "results": results}
+
+    def get_anime(self, anime_id, *args):
+        anime_page_url = f"{ANIWAVE_BASE}{anime_id}"
+        self.session.get(anime_page_url)
+        # TODO: to be continued; mostly js so very difficult

fastanime/libs/anime_provider/aniwave/constants.py

@@ -0,0 +1,20 @@
+ANIWAVE_BASE = "https://aniwave.to"
+
+SEARCH_HEADERS = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/png,image/svg+xml,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+    # 'Accept-Encoding': 'Utf-8',
+    "Referer": "https://aniwave.to/filter",
+    "DNT": "1",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "same-origin",
+    "Sec-Fetch-User": "?1",
+    "Connection": "keep-alive",
+    "Alt-Used": "aniwave.to",
+    # 'Cookie': '__pf=1; usertype=guest; session=BElk9DJdO3sFdDmLiGxuNiM9eGYO1TjktGsmdwjV',
+    "Priority": "u=0, i",
+    # Requests doesn't support trailers
+    # 'TE': 'trailers',
+}

fastanime/libs/anime_provider/base_provider.py

@@ -1,8 +1,13 @@
 import requests
+from yt_dlp.utils.networking import random_user_agent
 
 
 class AnimeProvider:
     session: requests.Session
 
+    USER_AGENT = random_user_agent()
+    HEADERS = {}
+
     def __init__(self) -> None:
         self.session = requests.session()
+        self.session.headers.update({"User-Agent": self.USER_AGENT, **self.HEADERS})

fastanime/libs/anime_provider/common.py

@@ -0,0 +1,15 @@
+import logging
+
+from requests import get
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_anime_info_from_bal(anilist_id):
+    try:
+        url = f"https://raw.githubusercontent.com/bal-mackup/mal-backup/master/anilist/anime/{anilist_id}.json"
+        response = get(url, timeout=11)
+        if response.status_code == 200:
+            return response.json()
+    except Exception as e:
+        logger.error(e)

fastanime/libs/anime_provider/mini_anilist.py

@@ -0,0 +1,153 @@
+import logging
+from typing import TYPE_CHECKING
+
+from requests import post
+from thefuzz import fuzz
+
+if TYPE_CHECKING:
+    from ..anilist.types import AnilistDataSchema
+logger = logging.getLogger(__name__)
+
+ANILIST_ENDPOINT = "https://graphql.anilist.co"
+"""
+query($query:String){
+    Page(perPage:50){
+        pageInfo{
+            total
+            currentPage
+            hasNextPage
+        }
+        media(search:$query,type:ANIME){
+        id
+        idMal
+        title{
+            romaji
+            english
+        }
+        episodes
+        status
+        nextAiringEpisode {
+            timeUntilAiring
+            airingAt
+            episode
+        }
+    }
+  }
+}
+"""
+
+
+def search_for_anime_with_anilist(anime_title: str):
+    query = """
+    query($query:String){
+        Page(perPage:50){
+            pageInfo{
+                total
+                currentPage
+                hasNextPage
+            }
+            media(search:$query,type:ANIME){
+                id
+                idMal
+                title{
+                    romaji
+                    english
+                }
+                episodes
+                status
+                nextAiringEpisode {
+                    timeUntilAiring
+                    airingAt
+                    episode
+                }
+            }
+        }
+    }
+    """
+    response = post(
+        ANILIST_ENDPOINT,
+        json={"query": query, "variables": {"query": anime_title}},
+        timeout=10,
+    )
+    if response.status_code == 200:
+        anilist_data: "AnilistDataSchema" = response.json()
+        return {
+            "pageInfo": anilist_data["data"]["Page"]["pageInfo"],
+            "results": [
+                {
+                    "id": anime_result["id"],
+                    "title": anime_result["title"]["romaji"]
+                    or anime_result["title"]["english"],
+                    "type": "anime",
+                    "availableEpisodes": list(
+                        range(
+                            1,
+                            (
+                                anime_result["episodes"]
+                                if not anime_result["status"] == "RELEASING"
+                                and anime_result["episodes"]
+                                else (
+                                    anime_result["nextAiringEpisode"]["episode"] - 1
+                                    if anime_result["nextAiringEpisode"]
+                                    else 0
+                                )
+                            ),
+                        )
+                    ),
+                }
+                for anime_result in anilist_data["data"]["Page"]["media"]
+            ],
+        }
+
+
+def get_mal_id_and_anilist_id(anime_title: str) -> "dict[str,int] | None":
+    """the abstraction over all none authenticated requests and that returns data of a similar type
+
+    Args:
+        query: the anilist query
+        variables: the anilist api variables
+
+    Returns:
+        a boolean indicating success and none or an anilist object depending on success
+    """
+    query = """
+    query($query:String){
+        Page(perPage:50){
+            pageInfo{
+                total
+                currentPage
+                hasNextPage
+            }
+            media(search:$query,type:ANIME){
+                    id
+                    idMal
+                title{
+                    romaji
+                    english
+                }
+            }
+        }
+    }
+    """
+
+    try:
+        variables = {"query": anime_title}
+        response = post(
+            ANILIST_ENDPOINT,
+            json={"query": query, "variables": variables},
+            timeout=10,
+        )
+        anilist_data: "AnilistDataSchema" = response.json()
+        if response.status_code == 200:
+            anime = max(
+                anilist_data["data"]["Page"]["media"],
+                key=lambda anime: max(
+                    (
+                        fuzz.ratio(anime, str(anime["title"]["romaji"])),
+                        fuzz.ratio(anime_title, str(anime["title"]["english"])),
+                    )
+                ),
+            )
+            return {"id_anilist": anime["id"], "id_mal": anime["idMal"]}
+    except Exception as e:
+        logger.error(f"Something unexpected occured {e}")

fastanime/libs/anime_provider/types.py

@@ -39,9 +39,20 @@ class AnimeEpisodeDetails(TypedDict):
     raw: list[str]
 
 
-class AnimeEpisode(TypedDict):
+#
+# class AnimeEpisode(TypedDict):
+#     id: str
+#     title: str
+#
+
+
+class AnimeEpisodeInfo(TypedDict):
     id: str
     title: str
+    episode: str
+    poster: str | None
+    duration: str | None
+    translation_type: str | None
 
 
 class Anime(TypedDict):
@@ -49,7 +60,7 @@ class Anime(TypedDict):
     title: str
     availableEpisodesDetail: AnimeEpisodeDetails
     type: str | None
-    episodesInfo: list[AnimeEpisode] | None
+    episodesInfo: list[AnimeEpisodeInfo] | None
     poster: str
     year: str
 
@@ -64,8 +75,15 @@ class EpisodeStream(TypedDict):
     translation_type: Literal["dub", "sub"]
 
 
+class Subtitle(TypedDict):
+    url: str
+    language: str
+
+
 class Server(TypedDict):
     headers: dict
+    subtitles: list[Subtitle]
+    audio: list
     server: str
     episode_title: str
     links: list[EpisodeStream]

fastanime/libs/anime_provider/utils.py

@@ -35,12 +35,12 @@ hex_to_char = {
 }
 
 
-def give_random_quality(links: list[dict]):
+def give_random_quality(links):
     qualities = cycle(["1080", "720", "480", "360"])
 
     return [
-        {"link": link["link"], "quality": quality}
-        for link, quality in zip(links, qualities)
+        {**episode_stream, "quality": quality}
+        for episode_stream, quality in zip(links, qualities)
     ]
 
 

poetry.lock

@@ -194,13 +194,13 @@ cffi = ">=1.0.0"
 
 [[package]]
 name = "cachetools"
-version = "5.4.0"
+version = "5.5.0"
 description = "Extensible memoizing collections and decorators"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "cachetools-5.4.0-py3-none-any.whl", hash = "sha256:3ae3b49a3d5e28a77a0be2b37dbcb89005058959cb2323858c2657c4a8cab474"},
-    {file = "cachetools-5.4.0.tar.gz", hash = "sha256:b8adc2e7c07f105ced7bc56dbb6dfbe7c4a00acce20e2227b3f355be89bc6827"},
+    {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"},
+    {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"},
 ]
 
 [[package]]
@@ -845,13 +845,13 @@ testing = ["covdefaults (>=2.3)", "pytest (>=8.2.2)", "pytest-cov (>=5)", "pytes
 
 [[package]]
 name = "pyright"
-version = "1.1.376"
+version = "1.1.377"
 description = "Command line wrapper for pyright"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "pyright-1.1.376-py3-none-any.whl", hash = "sha256:0f2473b12c15c46b3207f0eec224c3cea2bdc07cd45dd4a037687cbbca0fbeff"},
-    {file = "pyright-1.1.376.tar.gz", hash = "sha256:bffd63b197cd0810395bb3245c06b01f95a85ddf6bfa0e5644ed69c841e954dd"},
+    {file = "pyright-1.1.377-py3-none-any.whl", hash = "sha256:af0dd2b6b636c383a6569a083f8c5a8748ae4dcde5df7914b3f3f267e14dd162"},
+    {file = "pyright-1.1.377.tar.gz", hash = "sha256:aabc30fedce0ded34baa0c49b24f10e68f4bfc8f68ae7f3d175c4b0f256b4fcf"},
 ]
 
 [package.dependencies]
@@ -1243,83 +1243,97 @@ files = [
 
 [[package]]
 name = "websockets"
-version = "12.0"
+version = "13.0"
 description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "websockets-12.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d554236b2a2006e0ce16315c16eaa0d628dab009c33b63ea03f41c6107958374"},
-    {file = "websockets-12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2d225bb6886591b1746b17c0573e29804619c8f755b5598d875bb4235ea639be"},
-    {file = "websockets-12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eb809e816916a3b210bed3c82fb88eaf16e8afcf9c115ebb2bacede1797d2547"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c588f6abc13f78a67044c6b1273a99e1cf31038ad51815b3b016ce699f0d75c2"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5aa9348186d79a5f232115ed3fa9020eab66d6c3437d72f9d2c8ac0c6858c558"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6350b14a40c95ddd53e775dbdbbbc59b124a5c8ecd6fbb09c2e52029f7a9f480"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:70ec754cc2a769bcd218ed8d7209055667b30860ffecb8633a834dde27d6307c"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6e96f5ed1b83a8ddb07909b45bd94833b0710f738115751cdaa9da1fb0cb66e8"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4d87be612cbef86f994178d5186add3d94e9f31cc3cb499a0482b866ec477603"},
-    {file = "websockets-12.0-cp310-cp310-win32.whl", hash = "sha256:befe90632d66caaf72e8b2ed4d7f02b348913813c8b0a32fae1cc5fe3730902f"},
-    {file = "websockets-12.0-cp310-cp310-win_amd64.whl", hash = "sha256:363f57ca8bc8576195d0540c648aa58ac18cf85b76ad5202b9f976918f4219cf"},
-    {file = "websockets-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5d873c7de42dea355d73f170be0f23788cf3fa9f7bed718fd2830eefedce01b4"},
-    {file = "websockets-12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3f61726cae9f65b872502ff3c1496abc93ffbe31b278455c418492016e2afc8f"},
-    {file = "websockets-12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed2fcf7a07334c77fc8a230755c2209223a7cc44fc27597729b8ef5425aa61a3"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e332c210b14b57904869ca9f9bf4ca32f5427a03eeb625da9b616c85a3a506c"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5693ef74233122f8ebab026817b1b37fe25c411ecfca084b29bc7d6efc548f45"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e9e7db18b4539a29cc5ad8c8b252738a30e2b13f033c2d6e9d0549b45841c04"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6e2df67b8014767d0f785baa98393725739287684b9f8d8a1001eb2839031447"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bea88d71630c5900690fcb03161ab18f8f244805c59e2e0dc4ffadae0a7ee0ca"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dff6cdf35e31d1315790149fee351f9e52978130cef6c87c4b6c9b3baf78bc53"},
-    {file = "websockets-12.0-cp311-cp311-win32.whl", hash = "sha256:3e3aa8c468af01d70332a382350ee95f6986db479ce7af14d5e81ec52aa2b402"},
-    {file = "websockets-12.0-cp311-cp311-win_amd64.whl", hash = "sha256:25eb766c8ad27da0f79420b2af4b85d29914ba0edf69f547cc4f06ca6f1d403b"},
-    {file = "websockets-12.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0e6e2711d5a8e6e482cacb927a49a3d432345dfe7dea8ace7b5790df5932e4df"},
-    {file = "websockets-12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dbcf72a37f0b3316e993e13ecf32f10c0e1259c28ffd0a85cee26e8549595fbc"},
-    {file = "websockets-12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12743ab88ab2af1d17dd4acb4645677cb7063ef4db93abffbf164218a5d54c6b"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b645f491f3c48d3f8a00d1fce07445fab7347fec54a3e65f0725d730d5b99cb"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9893d1aa45a7f8b3bc4510f6ccf8db8c3b62120917af15e3de247f0780294b92"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f38a7b376117ef7aff996e737583172bdf535932c9ca021746573bce40165ed"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f764ba54e33daf20e167915edc443b6f88956f37fb606449b4a5b10ba42235a5"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:1e4b3f8ea6a9cfa8be8484c9221ec0257508e3a1ec43c36acdefb2a9c3b00aa2"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9fdf06fd06c32205a07e47328ab49c40fc1407cdec801d698a7c41167ea45113"},
-    {file = "websockets-12.0-cp312-cp312-win32.whl", hash = "sha256:baa386875b70cbd81798fa9f71be689c1bf484f65fd6fb08d051a0ee4e79924d"},
-    {file = "websockets-12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ae0a5da8f35a5be197f328d4727dbcfafa53d1824fac3d96cdd3a642fe09394f"},
-    {file = "websockets-12.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5f6ffe2c6598f7f7207eef9a1228b6f5c818f9f4d53ee920aacd35cec8110438"},
-    {file = "websockets-12.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9edf3fc590cc2ec20dc9d7a45108b5bbaf21c0d89f9fd3fd1685e223771dc0b2"},
-    {file = "websockets-12.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8572132c7be52632201a35f5e08348137f658e5ffd21f51f94572ca6c05ea81d"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:604428d1b87edbf02b233e2c207d7d528460fa978f9e391bd8aaf9c8311de137"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a9d160fd080c6285e202327aba140fc9a0d910b09e423afff4ae5cbbf1c7205"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87b4aafed34653e465eb77b7c93ef058516cb5acf3eb21e42f33928616172def"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b2ee7288b85959797970114deae81ab41b731f19ebcd3bd499ae9ca0e3f1d2c8"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7fa3d25e81bfe6a89718e9791128398a50dec6d57faf23770787ff441d851967"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a571f035a47212288e3b3519944f6bf4ac7bc7553243e41eac50dd48552b6df7"},
-    {file = "websockets-12.0-cp38-cp38-win32.whl", hash = "sha256:3c6cc1360c10c17463aadd29dd3af332d4a1adaa8796f6b0e9f9df1fdb0bad62"},
-    {file = "websockets-12.0-cp38-cp38-win_amd64.whl", hash = "sha256:1bf386089178ea69d720f8db6199a0504a406209a0fc23e603b27b300fdd6892"},
-    {file = "websockets-12.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ab3d732ad50a4fbd04a4490ef08acd0517b6ae6b77eb967251f4c263011a990d"},
-    {file = "websockets-12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1d9697f3337a89691e3bd8dc56dea45a6f6d975f92e7d5f773bc715c15dde28"},
-    {file = "websockets-12.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1df2fbd2c8a98d38a66f5238484405b8d1d16f929bb7a33ed73e4801222a6f53"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23509452b3bc38e3a057382c2e941d5ac2e01e251acce7adc74011d7d8de434c"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e5fc14ec6ea568200ea4ef46545073da81900a2b67b3e666f04adf53ad452ec"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46e71dbbd12850224243f5d2aeec90f0aaa0f2dde5aeeb8fc8df21e04d99eff9"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b81f90dcc6c85a9b7f29873beb56c94c85d6f0dac2ea8b60d995bd18bf3e2aae"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:a02413bc474feda2849c59ed2dfb2cddb4cd3d2f03a2fedec51d6e959d9b608b"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bbe6013f9f791944ed31ca08b077e26249309639313fff132bfbf3ba105673b9"},
-    {file = "websockets-12.0-cp39-cp39-win32.whl", hash = "sha256:cbe83a6bbdf207ff0541de01e11904827540aa069293696dd528a6640bd6a5f6"},
-    {file = "websockets-12.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc4e7fa5414512b481a2483775a8e8be7803a35b30ca805afa4998a84f9fd9e8"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:248d8e2446e13c1d4326e0a6a4e9629cb13a11195051a73acf414812700badbd"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f44069528d45a933997a6fef143030d8ca8042f0dfaad753e2906398290e2870"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4e37d36f0d19f0a4413d3e18c0d03d0c268ada2061868c1e6f5ab1a6d575077"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d829f975fc2e527a3ef2f9c8f25e553eb7bc779c6665e8e1d52aa22800bb38b"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2c71bd45a777433dd9113847af751aae36e448bc6b8c361a566cb043eda6ec30"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0bee75f400895aef54157b36ed6d3b308fcab62e5260703add87f44cee9c82a6"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:423fc1ed29f7512fceb727e2d2aecb952c46aa34895e9ed96071821309951123"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27a5e9964ef509016759f2ef3f2c1e13f403725a5e6a1775555994966a66e931"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3181df4583c4d3994d31fb235dc681d2aaad744fbdbf94c4802485ececdecf2"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:b067cb952ce8bf40115f6c19f478dc71c5e719b7fbaa511359795dfd9d1a6468"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:00700340c6c7ab788f176d118775202aadea7602c5cc6be6ae127761c16d6b0b"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e469d01137942849cff40517c97a30a93ae79917752b34029f0ec72df6b46399"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffefa1374cd508d633646d51a8e9277763a9b78ae71324183693959cf94635a7"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba0cab91b3956dfa9f512147860783a1829a8d905ee218a9837c18f683239611"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2cb388a5bfb56df4d9a406783b7f9dbefb888c09b71629351cc6b036e9259370"},
-    {file = "websockets-12.0-py3-none-any.whl", hash = "sha256:dc284bbc8d7c78a6c69e0c7325ab46ee5e40bb4d50e494d8131a07ef47500e9e"},
-    {file = "websockets-12.0.tar.gz", hash = "sha256:81df9cbcbb6c260de1e007e58c011bfebe2dafc8435107b0537f393dd38c8b1b"},
+    {file = "websockets-13.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ad4fa707ff9e2ffee019e946257b5300a45137a58f41fbd9a4db8e684ab61528"},
+    {file = "websockets-13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6fd757f313c13c34dae9f126d3ba4cf97175859c719e57c6a614b781c86b617e"},
+    {file = "websockets-13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cbac2eb7ce0fac755fb983c9247c4a60c4019bcde4c0e4d167aeb17520cc7ef1"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4b83cf7354cbbc058e97b3e545dceb75b8d9cf17fd5a19db419c319ddbaaf7a"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9202c0010c78fad1041e1c5285232b6508d3633f92825687549540a70e9e5901"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6566e79c8c7cbea75ec450f6e1828945fc5c9a4769ceb1c7b6e22470539712"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e7fcad070dcd9ad37a09d89a4cbc2a5e3e45080b88977c0da87b3090f9f55ead"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a8f7d65358a25172db00c69bcc7df834155ee24229f560d035758fd6613111a"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:63b702fb31e3f058f946ccdfa551f4d57a06f7729c369e8815eb18643099db37"},
+    {file = "websockets-13.0-cp310-cp310-win32.whl", hash = "sha256:3a20cf14ba7b482c4a1924b5e061729afb89c890ca9ed44ac4127c6c5986e424"},
+    {file = "websockets-13.0-cp310-cp310-win_amd64.whl", hash = "sha256:587245f0704d0bb675f919898d7473e8827a6d578e5a122a21756ca44b811ec8"},
+    {file = "websockets-13.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:06df8306c241c235075d2ae77367038e701e53bc8c1bb4f6644f4f53aa6dedd0"},
+    {file = "websockets-13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:85a1f92a02f0b8c1bf02699731a70a8a74402bb3f82bee36e7768b19a8ed9709"},
+    {file = "websockets-13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9ed02c604349068d46d87ef4c2012c112c791f2bec08671903a6bb2bd9c06784"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b89849171b590107f6724a7b0790736daead40926ddf47eadf998b4ff51d6414"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:939a16849d71203628157a5e4a495da63967c744e1e32018e9b9e2689aca64d4"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad818cdac37c0ad4c58e51cb4964eae4f18b43c4a83cb37170b0d90c31bd80cf"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cbfe82a07596a044de78bb7a62519e71690c5812c26c5f1d4b877e64e4f46309"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e07e76c49f39c5b45cbd7362b94f001ae209a3ea4905ae9a09cfd53b3c76373d"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:372f46a0096cfda23c88f7e42349a33f8375e10912f712e6b496d3a9a557290f"},
+    {file = "websockets-13.0-cp311-cp311-win32.whl", hash = "sha256:376a43a4fd96725f13450d3d2e98f4f36c3525c562ab53d9a98dd2950dca9a8a"},
+    {file = "websockets-13.0-cp311-cp311-win_amd64.whl", hash = "sha256:2be1382a4daa61e2f3e2be3b3c86932a8db9d1f85297feb6e9df22f391f94452"},
+    {file = "websockets-13.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5407c34776b9b77bd89a5f95eb0a34aaf91889e3f911c63f13035220eb50107"},
+    {file = "websockets-13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4782ec789f059f888c1e8fdf94383d0e64b531cffebbf26dd55afd53ab487ca4"},
+    {file = "websockets-13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c8feb8e19ef65c9994e652c5b0324abd657bedd0abeb946fb4f5163012c1e730"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3f3d2e20c442b58dbac593cb1e02bc02d149a86056cc4126d977ad902472e3b"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e39d393e0ab5b8bd01717cc26f2922026050188947ff54fe6a49dc489f7750b7"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f661a4205741bdc88ac9c2b2ec003c72cee97e4acd156eb733662ff004ba429"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:384129ad0490e06bab2b98c1da9b488acb35bb11e2464c728376c6f55f0d45f3"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:df5c0eff91f61b8205a6c9f7b255ff390cdb77b61c7b41f79ca10afcbb22b6cb"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:02cc9bb1a887dac0e08bf657c5d00aa3fac0d03215d35a599130c2034ae6663a"},
+    {file = "websockets-13.0-cp312-cp312-win32.whl", hash = "sha256:d9726d2c9bd6aed8cb994d89b3910ca0079406edce3670886ec828a73e7bdd53"},
+    {file = "websockets-13.0-cp312-cp312-win_amd64.whl", hash = "sha256:fa0839f35322f7b038d8adcf679e2698c3a483688cc92e3bd15ee4fb06669e9a"},
+    {file = "websockets-13.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:da7e501e59857e8e3e9d10586139dc196b80445a591451ca9998aafba1af5278"},
+    {file = "websockets-13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a00e1e587c655749afb5b135d8d3edcfe84ec6db864201e40a882e64168610b3"},
+    {file = "websockets-13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a7fbf2a8fe7556a8f4e68cb3e736884af7bf93653e79f6219f17ebb75e97d8f0"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ea9c9c7443a97ea4d84d3e4d42d0e8c4235834edae652993abcd2aff94affd7"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:35c2221b539b360203f3f9ad168e527bf16d903e385068ae842c186efb13d0ea"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:358d37c5c431dd050ffb06b4b075505aae3f4f795d7fff9794e5ed96ce99b998"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:038e7a0f1bfafc7bf52915ab3506b7a03d1e06381e9f60440c856e8918138151"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fd038bc9e2c134847f1e0ce3191797fad110756e690c2fdd9702ed34e7a43abb"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93b8c2008f372379fb6e5d2b3f7c9ec32f7b80316543fd3a5ace6610c5cde1b0"},
+    {file = "websockets-13.0-cp313-cp313-win32.whl", hash = "sha256:851fd0afb3bc0b73f7c5b5858975d42769a5fdde5314f4ef2c106aec63100687"},
+    {file = "websockets-13.0-cp313-cp313-win_amd64.whl", hash = "sha256:7d14901fdcf212804970c30ab9ee8f3f0212e620c7ea93079d6534863444fb4e"},
+    {file = "websockets-13.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ae7a519a56a714f64c3445cabde9fc2fc927e7eae44f413eae187cddd9e54178"},
+    {file = "websockets-13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5575031472ca87302aeb2ce2c2349f4c6ea978c86a9d1289bc5d16058ad4c10a"},
+    {file = "websockets-13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9895df6cd0bfe79d09bcd1dbdc03862846f26fbd93797153de954306620c1d00"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4de299c947a54fca9ce1c5fd4a08eb92ffce91961becb13bd9195f7c6e71b47"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05c25f7b849702950b6fd0e233989bb73a0d2bc83faa3b7233313ca395205f6d"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ede95125a30602b1691a4b1da88946bf27dae283cf30f22cd2cb8ca4b2e0d119"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:addf0a16e4983280efed272d8cb3b2e05f0051755372461e7d966b80a6554e16"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:06b3186e97bf9a33921fa60734d5ed90f2a9b407cce8d23c7333a0984049ef61"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:eae368cac85adc4c7dc3b0d5f84ffcca609d658db6447387300478e44db70796"},
+    {file = "websockets-13.0-cp38-cp38-win32.whl", hash = "sha256:337837ac788d955728b1ab01876d72b73da59819a3388e1c5e8e05c3999f1afa"},
+    {file = "websockets-13.0-cp38-cp38-win_amd64.whl", hash = "sha256:f66e00e42f25ca7e91076366303e11c82572ca87cc5aae51e6e9c094f315ab41"},
+    {file = "websockets-13.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:94c1c02721139fe9940b38d28fb15b4b782981d800d5f40f9966264fbf23dcc8"},
+    {file = "websockets-13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd4ba86513430513e2aa25a441bb538f6f83734dc368a2c5d18afdd39097aa33"},
+    {file = "websockets-13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a1ab8f0e0cadc5be5f3f9fa11a663957fecbf483d434762c8dfb8aa44948944a"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3670def5d3dfd5af6f6e2b3b243ea8f1f72d8da1ef927322f0703f85c90d9603"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6058b6be92743358885ad6dcdecb378fde4a4c74d4dd16a089d07580c75a0e80"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:516062a0a8ef5ecbfa4acbaec14b199fc070577834f9fe3d40800a99f92523ca"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:da7e918d82e7bdfc6f66d31febe1b2e28a1ca3387315f918de26f5e367f61572"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:9cc7f35dcb49a4e32db82a849fcc0714c4d4acc9d2273aded2d61f87d7f660b7"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f5737c53eb2c8ed8f64b50d3dafd3c1dae739f78aa495a288421ac1b3de82717"},
+    {file = "websockets-13.0-cp39-cp39-win32.whl", hash = "sha256:265e1f0d3f788ce8ef99dca591a1aec5263b26083ca0934467ad9a1d1181067c"},
+    {file = "websockets-13.0-cp39-cp39-win_amd64.whl", hash = "sha256:4d70c89e3d3b347a7c4d3c33f8d323f0584c9ceb69b82c2ef8a174ca84ea3d4a"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:602cbd010d8c21c8475f1798b705bb18567eb189c533ab5ef568bc3033fdf417"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:bf8eb5dca4f484a60f5327b044e842e0d7f7cdbf02ea6dc4a4f811259f1f1f0b"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d795c1802d99a643bf689b277e8604c14b5af1bc0a31dade2cd7a678087212"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:788bc841d250beccff67a20a5a53a15657a60111ef9c0c0a97fbdd614fae0fe2"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7334752052532c156d28b8eaf3558137e115c7871ea82adff69b6d94a7bee273"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7a1963302947332c3039e3f66209ec73b1626f8a0191649e0713c391e9f5b0d"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2e1cf4e1eb84b4fd74a47688e8b0940c89a04ad9f6937afa43d468e71128cd68"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:c026ee729c4ce55708a14b839ba35086dfae265fc12813b62d34ce33f4980c1c"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5f9d23fbbf96eefde836d9692670bfc89e2d159f456d499c5efcf6a6281c1af"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ad684cb7efce227d756bae3e8484f2e56aa128398753b54245efdfbd1108f2c"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1e10b3fbed7be4a59831d3a939900e50fcd34d93716e433d4193a4d0d1d335d"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d42a818e634f789350cd8fb413a3f5eec1cf0400a53d02062534c41519f5125c"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e5ba5e9b332267d0f2c33ede390061850f1ac3ee6cd1bdcf4c5ea33ead971966"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:f9af457ed593e35f467140d8b61d425495b127744a9d65d45a366f8678449a23"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcea3eb58c09c3a31cc83b45c06d5907f02ddaf10920aaa6443975310f699b95"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c210d1460dc8d326ffdef9703c2f83269b7539a1690ad11ae04162bc1878d33d"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b32f38bc81170fd56d0482d505b556e52bf9078b36819a8ba52624bd6667e39e"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:81a11a1ddd5320429db47c04d35119c3e674d215173d87aaeb06ae80f6e9031f"},
+    {file = "websockets-13.0-py3-none-any.whl", hash = "sha256:dbbac01e80aee253d44c4f098ab3cc17c822518519e869b284cfbb8cd16cc9de"},
+    {file = "websockets-13.0.tar.gz", hash = "sha256:b7bf950234a482b7461afdb2ec99eee3548ec4d53f418c7990bb79c620476602"},
 ]
 
 [[package]]

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastanime"
-version = "2.2.4"
+version = "2.3.8"
 description = "A browser anime site experience from the terminal"
 authors = ["Benextempest <benextempest@gmail.com>"]
 license = "UNLICENSE"

pyrightconfig.json

@@ -1,4 +1,5 @@
 {
-  "typeCheckingMode": "standard",
-  "reportPrivateImportUsage": false
+  "venvPath": ".",
+  "venv": ".venv",
+  "pythonVersion": "3.10"
 }

tests/test_all_commands.py

@@ -60,6 +60,11 @@ def test_update_help(runner: CliRunner):
     assert result.exit_code == 0
 
 
+def test_grab_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["grab", "--help"])
+    assert result.exit_code == 0
+
+
 def test_anilist_help(runner: CliRunner):
     result = runner.invoke(run_cli, ["anilist", "--help"])
     assert result.exit_code == 0