fix(downloads): typing issue

README.md

@@ -44,6 +44,7 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
       - [downloads subcommand](#downloads-subcommand)
       - [config subcommand](#config-subcommand)
       - [cache subcommand](#cache-subcommand)
+      - [completions subcommand](#completions-subcommand)
   - [MPV specific commands](#mpv-specific-commands)
     - [Added keybindings](#added-keybindings)
     - [Added script messages](#added-script-messages)
@@ -55,7 +56,7 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
 
 > [!IMPORTANT]
 >
-> This project currently scrapes allanime and is in no way related to them. The site is in the public domain and can be access by any one with a browser.
+> This project currently scrapes allanime and animepahe and is in no way related to them nor does the project own any content servers. The site is in the public domain and can be access by any one with a browser.
 
 ## Installation
 
@@ -151,7 +152,7 @@ fastanime --version
 
 ### External Dependencies
 
-The only required external dependency, unless you won't be streaming, is [MPV](https://mpv.io/installation/), which i recommend installing with [uosc](https://github.com/tomasklaen/uosc) and [thumbfast](https://github.com/po5/thumbfast) for the best experience since they add a better interface to it.
+The only required external dependency, unless you won't be streaming, is [MPV](https://mpv.io/installation/), which i recommend installing with [uosc](https://github.com/tomasklaen/uosc) :fire: and [thumbfast](https://github.com/po5/thumbfast) for the best experience since they add a better interface to it.
 
 > [!NOTE]
 >
@@ -166,7 +167,7 @@ The only required external dependency, unless you won't be streaming, is [MPV](h
 - [chafa](https://github.com/hpjansson/chafa) currently the best cross platform and cross terminal image viewer for the terminal.
 - [icat](https://sw.kovidgoyal.net/kitty/kittens/icat/) an image viewer that only works in [kitty terminal](https://sw.kovidgoyal.net/kitty/), which is currently the best terminal in my opinion, and by far the best image renderer for the terminal thanks to kitty's terminal graphics protocol. Its terminal graphics is so op that you can [run a browser on it](https://github.com/chase/awrit?tab=readme-ov-file)!!
 - [bash](https://www.gnu.org/software/bash/) is used as the preview script language.
-- [ani-skip](https://github.com/synacktraa/ani-skip) :fire: used for skipping the opening and ending theme songs
+- [ani-skip](https://github.com/synacktraa/ani-skip) used for skipping the opening and ending theme songs
 
 ## Usage
 
@@ -216,6 +217,7 @@ Available options include:
 - `--log` allow logging to stdout
 - `--log-file` allow logging to a file
 - `--rich-traceback` allow rich traceback
+- `--use-mpv-mod/--use-default-player` whether to use python-mpv
 
 #### The anilist command :fire: :fire: :fire:
 
@@ -372,6 +374,23 @@ fastanime cache --size
 fastanime cache
 ```
 
+#### completions subcommand
+
+Helper command to setup shell completions
+
+**Syntax:**
+
+```bash
+# try to detect your shell and print completions
+fastanime completions
+# print fish completions
+fastanime completions --fish
+# print bash completions
+fastanime completions --bash
+# print zsh completions
+fastanime completions --zsh
+```
+
 ## MPV specific commands
 
 The project now allows on the fly media controls directly from mpv. This means you can go to the next or previous episode without the window ever closing thus offering a seamless experience.
@@ -387,12 +406,17 @@ This is all powered with [python-mpv]() which enables writing mpv scripts with p
 
 `<shift>+a` toggle auto next episode
 
+`<shit>+r` reload episode
+
 ### Added script messages
 
 Examples:
 
 ```bash
+# to select episode from mpv without window closing
 script-message select-episode <episode-number>
+# to select server from mpv without window closing
+script-message select-server <server-name>
 ```
 
 ## Configuration
@@ -414,7 +438,7 @@ skip=false
 # the maximum delta time in minutes after which the episode should be considered as completed
 # used in the continue from time stamp
 error=3
-use_mpv_mod=True
+use_mpv_mod=False
 
 # the format of downloaded anime and trailer
 # based on yt-dlp format and passed directly to it
@@ -425,6 +449,9 @@ use_mpv_mod=True
 format=best[height<=1080]/bestvideo[height<=1080]+bestaudio/best # default
 
 [general]
+# can be [allanime,animepahe]
+provider = allanime
+
 preferred_language = romaji  # Display language (options: english, romaji)
 downloads_dir = <Default-videos-dir>/FastAnime  # Download directory
 preview=false # whether to show a preview window when using fzf or rofi

fastanime/AnimeProvider.py

@@ -12,7 +12,7 @@ from .libs.anime_provider import anime_sources
 if TYPE_CHECKING:
     from typing import Iterator
 
-    from .libs.anilist.anilist_data_schema import AnilistBaseMediaDataSchema
+    from .libs.anilist.types import AnilistBaseMediaDataSchema
     from .libs.anime_provider.types import Anime, SearchResults, Server
 
 logger = logging.getLogger(__name__)

fastanime/Utility/anilist_data_helper.py

@@ -1,9 +1,6 @@
 from datetime import datetime
 
-from ..libs.anilist.anilist_data_schema import (
-    AnilistDateObject,
-    AnilistMediaNextAiringEpisode,
-)
+from ..libs.anilist.types import AnilistDateObject, AnilistMediaNextAiringEpisode
 
 
 # TODO: Add formating options for the final date

fastanime/Utility/downloader/downloader.py

@@ -3,8 +3,7 @@ from queue import Queue
 from threading import Thread
 
 import yt_dlp
-
-from ..utils import sanitize_filename
+from yt_dlp.utils import sanitize_filename
 
 logger = logging.getLogger(__name__)
 

fastanime/Utility/utils.py

@@ -5,7 +5,7 @@ from functools import lru_cache
 
 from thefuzz import fuzz
 
-from fastanime.libs.anilist.anilist_data_schema import AnilistBaseMediaDataSchema
+from fastanime.libs.anilist.types import AnilistBaseMediaDataSchema
 
 from .data import anime_normalizer
 

fastanime/__init__.py

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

fastanime/cli/__init__.py

@@ -3,8 +3,7 @@ import signal
 import click
 
 from .. import __version__
-from ..libs.anime_provider import anime_sources
-from ..libs.anime_provider.allanime.constants import SERVERS_AVAILABLE
+from ..libs.anime_provider import SERVERS_AVAILABLE, anime_sources
 from ..Utility.data import anilist_sort_normalizer
 from .commands import LazyGroup
 
@@ -15,6 +14,7 @@ commands = {
     "config": "config.config",
     "downloads": "downloads.downloads",
     "cache": "cache.cache",
+    "completions": "completions.completions",
 }
 
 
@@ -52,7 +52,7 @@ signal.signal(signal.SIGINT, handle_exit)
 @click.option(
     "-s",
     "--server",
-    type=click.Choice([*SERVERS_AVAILABLE, "top"], case_sensitive=False),
+    type=click.Choice([*SERVERS_AVAILABLE, "top"]),
     help="Server of choice",
 )
 @click.option(
@@ -76,7 +76,7 @@ signal.signal(signal.SIGINT, handle_exit)
 @click.option(
     "-q",
     "--quality",
-    type=click.IntRange(0, 3),
+    type=click.Choice(["360", "720", "1080", "unknown"]),
     help="set the quality of the stream",
 )
 @click.option(
@@ -126,6 +126,9 @@ signal.signal(signal.SIGINT, handle_exit)
     help="Rofi theme to use for the user input prompt",
     type=click.Path(),
 )
+@click.option(
+    "--use-mpv-mod/--use-default-player", help="Whether to use python-mpv", type=bool
+)
 @click.pass_context
 def run_cli(
     ctx: click.Context,
@@ -155,6 +158,7 @@ def run_cli(
     rofi_theme,
     rofi_theme_confirm,
     rofi_theme_input,
+    use_mpv_mod,
 ):
     from .config import Config
 
@@ -196,7 +200,6 @@ def run_cli(
 
     if provider:
         ctx.obj.provider = provider
-        ctx.obj.load_config()
     if server:
         ctx.obj.server = server
     if format:
@@ -217,6 +220,11 @@ def run_cli(
         == click.core.ParameterSource.COMMANDLINE
     ):
         ctx.obj.auto_select = auto_select
+    if (
+        ctx.get_parameter_source("use_mpv_mod")
+        == click.core.ParameterSource.COMMANDLINE
+    ):
+        ctx.obj.use_mpv_mod = use_mpv_mod
     if sort_by:
         ctx.obj.sort_by = sort_by
     if downloads_dir:

fastanime/cli/commands/anilist/__init__.py

@@ -1,6 +1,6 @@
 import click
 
-from ...utils.tools import QueryDict
+from ...utils.tools import FastAnimeRuntimeState
 from .__lazyloader__ import LazyGroup
 
 commands = {
@@ -36,7 +36,9 @@ def anilist(ctx: click.Context):
 
     from ....anilist import AniList
     from ....AnimeProvider import AnimeProvider
-    from ...interfaces.anilist_interfaces import anilist as anilist_interface
+    from ...interfaces.anilist_interfaces import (
+        fastanime_main_menu as anilist_interface,
+    )
 
     if TYPE_CHECKING:
         from ...config import Config
@@ -45,5 +47,5 @@ def anilist(ctx: click.Context):
     if user := ctx.obj.user:
         AniList.update_login_info(user, user["token"])
     if ctx.invoked_subcommand is None:
-        anilist_config = QueryDict()
-        anilist_interface(ctx.obj, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        anilist_interface(ctx.obj, fastanime_runtime_state)

fastanime/cli/commands/anilist/completed.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def completed(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def completed(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    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

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def dropped(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def dropped(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    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

@@ -8,11 +8,11 @@ import click
 @click.pass_obj
 def favourites(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_favourite()
     if anime_data[0]:
-        anilist_config = QueryDict()
-        anilist_config.data = anime_data[1]
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_data[1]
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/paused.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def paused(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def paused(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
+    anilist_config = FastAnimeRuntimeState()
     anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    anilist_interfaces.anilist_results_menu(config, anilist_config)

fastanime/cli/commands/anilist/planning.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def planning(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def planning(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    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

@@ -7,11 +7,11 @@ import click
 @click.pass_obj
 def popular(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_popular()
     if anime_data[0]:
-        anilist_config = QueryDict()
-        anilist_config.data = anime_data[1]
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_data[1]
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/random_anime.py

@@ -10,8 +10,8 @@ def random_anime(config):
     import random
 
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     random_anime = range(1, 15000)
 
@@ -20,8 +20,8 @@ def random_anime(config):
     anime_data = AniList.search(id_in=list(random_anime))
 
     if anime_data[0]:
-        anilist_config = QueryDict()
-        anilist_config.data = anime_data[1]
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_data[1]
+        anilist_results_menu(config, fastanime_runtime_state)
     else:
         print(anime_data[1])

fastanime/cli/commands/anilist/recent.py

@@ -8,11 +8,11 @@ import click
 @click.pass_obj
 def recent(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_recently_updated()
     if anime_data[0]:
-        anilist_config = QueryDict()
-        anilist_config.data = anime_data[1]
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = anime_data[1]
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/rewatching.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def rewatching(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def rewatching(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    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

@@ -7,11 +7,11 @@ import click
 @click.pass_obj
 def scores(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     anime_data = AniList.get_most_scored()
     if anime_data[0]:
-        anilist_config = QueryDict()
-        anilist_config.data = anime_data[1]
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.data = anime_data[1]
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/search.py

@@ -11,11 +11,11 @@ import click
 @click.pass_obj
 def search(config, title):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     success, search_results = AniList.search(title)
     if success:
-        anilist_config = QueryDict()
-        anilist_config.data = search_results
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = search_results
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/trending.py

@@ -8,11 +8,11 @@ import click
 @click.pass_obj
 def trending(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     success, data = AniList.get_trending()
     if success:
-        anilist_config = QueryDict()
-        anilist_config.data = data
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = data
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/upcoming.py

@@ -7,11 +7,11 @@ import click
 @click.pass_obj
 def upcoming(config):
     from ....anilist import AniList
-    from ...interfaces.anilist_interfaces import select_anime
-    from ...utils.tools import QueryDict
+    from ...interfaces.anilist_interfaces import anilist_results_menu
+    from ...utils.tools import FastAnimeRuntimeState
 
     success, data = AniList.get_upcoming_anime()
     if success:
-        anilist_config = QueryDict()
-        anilist_config.data = data
-        select_anime(config, anilist_config)
+        fastanime_runtime_state = FastAnimeRuntimeState()
+        fastanime_runtime_state.anilist_data = data
+        anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/anilist/watching.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 def watching(config: "Config"):
     from ....anilist import AniList
     from ...interfaces import anilist_interfaces
-    from ...utils.tools import QueryDict, exit_app
+    from ...utils.tools import FastAnimeRuntimeState, exit_app
 
     if not config.user:
         print("Not authenticated")
@@ -27,6 +27,6 @@ def watching(config: "Config"):
         for mediaListItem in anime_list[1]["data"]["Page"]["mediaList"]
     ]  # pyright:ignore
     anime_list[1]["data"]["Page"]["media"] = media  # pyright:ignore
-    anilist_config = QueryDict()
-    anilist_config.data = anime_list[1]
-    anilist_interfaces.select_anime(config, anilist_config)
+    fastanime_runtime_state = FastAnimeRuntimeState()
+    fastanime_runtime_state.anilist_data = anime_list[1]
+    anilist_interfaces.anilist_results_menu(config, fastanime_runtime_state)

fastanime/cli/commands/cache.py

@@ -25,14 +25,14 @@ def cache(clean, path, size):
     elif size:
         import os
 
-        from ..utils.utils import sizeof_fmt
+        from ..utils.utils import format_bytes_to_human
 
         total_size = 0
         for dirpath, dirnames, filenames in os.walk(APP_CACHE_DIR):
             for f in filenames:
                 fp = os.path.join(dirpath, f)
                 total_size += os.path.getsize(fp)
-        print("Total Size: ", sizeof_fmt(total_size))
+        print("Total Size: ", format_bytes_to_human(total_size))
     else:
         import click
 

fastanime/cli/commands/completions.py

@@ -0,0 +1,124 @@
+import click
+
+
+@click.command(help="Helper command to get shell completions")
+@click.option("--fish", is_flag=True)
+@click.option("--zsh", is_flag=True)
+@click.option("--bash", is_flag=True)
+def completions(fish, zsh, bash):
+    if not fish or not zsh or not bash:
+        import os
+
+        shell_env = os.environ.get("SHELL", "")
+        if "fish" in shell_env:
+            current_shell = "fish"
+        elif "zsh" in shell_env:
+            current_shell = "zsh"
+        elif "bash" in shell_env:
+            current_shell = "bash"
+        else:
+            current_shell = None
+    else:
+        current_shell = None
+    if fish or current_shell == "fish" and not zsh and not bash:
+        print(
+            """
+function _fastanime_completion;
+    set -l response (env _FASTANIME_COMPLETE=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) fastanime);
+
+    for completion in $response;
+        set -l metadata (string split "," $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            echo $metadata[2];
+        end;
+    end;
+end;
+
+complete --no-files --command fastanime --arguments "(_fastanime_completion)";
+        """
+        )
+    elif zsh or current_shell == "zsh" and not bash:
+        print(
+            """
+#compdef fastanime
+
+_fastanime_completion() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[fastanime] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) _FASTANIME_COMPLETE=zsh_complete fastanime)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    # autoload from fpath, call function directly
+    _fastanime_completion "$@"
+else
+    # eval/source/. command, register function for later
+    compdef _fastanime_completion fastanime
+fi
+        """
+        )
+    elif bash or current_shell == "bash":
+        print(
+            """
+_fastanime_completion() {
+    local IFS=$'\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD _FASTANIME_COMPLETE=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+_fastanime_completion_setup() {
+    complete -o nosort -F _fastanime_completion fastanime
+}
+
+_fastanime_completion_setup;
+        """
+        )
+    else:
+        print("Could not detect shell")

fastanime/cli/commands/download.py

@@ -37,7 +37,7 @@ def download(config: "Config", anime_title, episode_range, highest_priority):
     from ...libs.fzf import fzf
     from ...Utility.downloader.downloader import downloader
     from ..utils.tools import exit_app
-    from ..utils.utils import fuzzy_inquirer
+    from ..utils.utils import filter_by_quality, fuzzy_inquirer
 
     anime_provider = AnimeProvider(config.provider)
 
@@ -70,7 +70,10 @@ def download(config: "Config", anime_title, episode_range, highest_priority):
         if config.use_fzf:
             search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
         else:
-            search_result = fuzzy_inquirer("Please Select title", choices)
+            search_result = fuzzy_inquirer(
+                choices,
+                "Please Select title",
+            )
 
     # ---- fetch anime ----
     with Progress() as progress:
@@ -104,36 +107,40 @@ def download(config: "Config", anime_title, episode_range, highest_priority):
                 if not streams:
                     print("No streams skipping")
                     continue
-
-            with Progress() as progress:
-                if highest_priority:
-                    progress.add_task("Fetching highest priority stream", total=None)
-                    streams = list(streams)
-                    links = [
-                        (link.get("priority", 0), link["link"])
-                        for server in streams
-                        for link in server["links"]
-                    ]
-                    link = max(links, key=lambda x: x[0])[1]
-                    episode_title = streams[0]["episode_title"]
-                elif config.server == "top":
-                    progress.add_task("Fetching Top Server", total=None)
+            # ---- fetch servers ----
+            if config.server == "top":
+                with Progress() as progress:
+                    progress.add_task("Fetching top server...", total=None)
                     server = next(streams)
-                    link = server["links"][config.quality]["link"]
-                    episode_title = server["episode_title"]
+                stream_link = filter_by_quality(config.quality, server["links"])
+                if not stream_link:
+                    print("Quality not found")
+                    input("Enter to continue")
+                    continue
+                link = stream_link["link"]
+                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.use_fzf:
+                    server = fzf.run(servers_names, "Select an link: ")
                 else:
-                    # TODO: Make this better but no rush whats the point of manual selection
-                    progress.add_task("Fetching links", total=None)
-                    streams = list(streams)
-                    links = [
-                        link["link"] for server in streams for link in server["links"]
-                    ]
-                    episode_title = streams[0]["episode_title"]
-                    if config.use_fzf:
-                        link = fzf.run(links, "Select link", "Links")
-                    else:
-                        link = fuzzy_inquirer("Select link", links)
+                    server = fuzzy_inquirer(
+                        servers_names,
+                        "Select link",
+                    )
+                stream_link = filter_by_quality(
+                    config.quality, servers[server]["links"]
+                )
+                if not stream_link:
+                    print("Quality not found")
+                    continue
+                link = stream_link["link"]
 
+                episode_title = servers[server]["episode_title"]
             print(f"[purple]Now Downloading:[/] {search_result} Episode {episode}")
 
             downloader._download_file(

fastanime/cli/commands/downloads.py

@@ -36,7 +36,10 @@ def downloads(config: "Config", path: bool):
         elif config.use_rofi:
             playlist_name = Rofi.run(playlists, "Enter Playlist Name")
         else:
-            playlist_name = fuzzy_inquirer("Enter Playlist Name: ", playlists)
+            playlist_name = fuzzy_inquirer(
+                playlists,
+                "Enter Playlist Name: ",
+            )
         if playlist_name == "Exit":
             exit_app()
             return

fastanime/cli/commands/search.py

@@ -26,7 +26,7 @@ def search(config: Config, anime_title: 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 fuzzy_inquirer
+    from ..utils.utils import filter_by_quality, fuzzy_inquirer
 
     anime_provider = AnimeProvider(config.provider)
 
@@ -63,8 +63,8 @@ def search(config: Config, anime_title: str, episode_range: str):
             search_result = Rofi.run(choices, "Please Select Title")
         else:
             search_result = fuzzy_inquirer(
-                "Please Select Title",
                 choices,
+                "Please Select Title",
             )
 
     # ---- fetch selected anime ----
@@ -102,6 +102,7 @@ def search(config: Config, anime_title: str, episode_range: str):
                 )
             except StopIteration:
                 print("[green]Completed binge sequence[/]:smile:")
+                input("Enter to continue...")
 
         if not episode or episode not in episodes:
             if config.use_fzf:
@@ -109,7 +110,10 @@ def search(config: Config, anime_title: str, episode_range: str):
             elif config.use_rofi:
                 episode = Rofi.run(episodes, "Select an episode")
             else:
-                episode = fuzzy_inquirer("Select episode", episodes)
+                episode = fuzzy_inquirer(
+                    episodes,
+                    "Select episode",
+                )
 
         # ---- fetch streams ----
         with Progress() as progress:
@@ -121,25 +125,51 @@ def search(config: Config, anime_title: str, episode_range: str):
                 print("Failed to get streams")
                 return
 
-        # ---- fetch servers ----
-        with Progress() as progress:
+        try:
+            # ---- fetch servers ----
             if config.server == "top":
-                progress.add_task("Fetching top server...", total=None)
-                server = next(streams)
-                link = server["links"][config.quality]["link"]
+                with Progress() as progress:
+                    progress.add_task("Fetching top server...", total=None)
+                    server = next(streams)
+                stream_link = filter_by_quality(config.quality, server["links"])
+                if not stream_link:
+                    print("Quality not found")
+                    input("Enter to continue")
+                    stream_anime()
+                    return
+                link = stream_link["link"]
+                episode_title = server["episode_title"]
             else:
-                progress.add_task("Fetching servers", total=None)
-                links = [link["link"] for server in streams for link in server["links"]]
+                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.use_fzf:
-                    link = fzf.run(links, "Select an link: ", header=search_result)
+                    server = fzf.run(servers_names, "Select an link: ")
                 elif config.use_rofi:
-                    link = Rofi.run(links, "Select an link")
+                    server = Rofi.run(servers_names, "Select an link")
                 else:
-                    link = fuzzy_inquirer("Select link", links)
+                    server = fuzzy_inquirer(
+                        servers_names,
+                        "Select link",
+                    )
+                stream_link = filter_by_quality(
+                    config.quality, servers[server]["links"]
+                )
+                if not stream_link:
+                    print("Quality not found")
+                    input("Enter to continue")
+                    stream_anime()
+                    return
+                link = stream_link["link"]
+                episode_title = servers[server]["episode_title"]
+            print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
 
-        print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
-
-        run_mpv(link, search_result)
+            run_mpv(link, episode_title)
+        except Exception as e:
+            print(e)
+            input("Enter to continue")
         stream_anime()
 
     stream_anime()

fastanime/cli/config.py

@@ -28,7 +28,7 @@ class Config(object):
             {
                 "server": "top",
                 "continue_from_history": "True",
-                "quality": "0",
+                "quality": "1080",
                 "auto_next": "False",
                 "auto_select": "True",
                 "sort_by": "search match",
@@ -47,7 +47,7 @@ class Config(object):
                 "rofi_theme": "",
                 "rofi_theme_input": "",
                 "rofi_theme_confirm": "",
-                "use_mpv_mod": "true",
+                "use_mpv_mod": "false",
                 "force_window": "immediate",
             }
         )
@@ -175,7 +175,7 @@ class Config(object):
         return self.configparser.getboolean("stream", "auto_select")
 
     def get_quality(self):
-        return self.configparser.getint("stream", "quality")
+        return self.configparser.get("stream", "quality")
 
     def get_use_mpv_mod(self):
         return self.configparser.getboolean("stream", "use_mpv_mod")

fastanime/cli/interfaces/utils.py

@@ -9,13 +9,15 @@ from threading import Thread
 import requests
 
 from ...constants import APP_CACHE_DIR
-from ...libs.anilist.anilist_data_schema import AnilistBaseMediaDataSchema
+from ...libs.anilist.types import AnilistBaseMediaDataSchema
 from ...Utility import anilist_data_helper
 from ...Utility.utils import remove_html_tags
 from ..utils.utils import get_true_fg
 
 logger = logging.getLogger(__name__)
 
+# this script was written by the fzf devs as an example on how to preview images
+# its only here for convinience
 fzf_preview = r"""
 #
 # The purpose of this script is to demonstrate how to preview a file or an
@@ -95,7 +97,16 @@ fzf-preview(){
 
 
 # ---- aniskip intergration ----
-def aniskip(mal_id, episode):
+def aniskip(mal_id: int, episode: str):
+    """helper function to be used for setting and getting skip data
+
+    Args:
+        mal_id: mal id of the anime
+        episode: episode number
+
+    Returns:
+        mpv chapter options
+    """
     ANISKIP = shutil.which("ani-skip")
     if not ANISKIP:
         print("Aniskip not found, please install and try again")
@@ -111,37 +122,61 @@ def aniskip(mal_id, episode):
 # ---- prevew stuff ----
 # import tempfile
 
+# NOTE: May change this to a temp dir but there were issues so later
 WORKING_DIR = APP_CACHE_DIR  # tempfile.gettempdir()
-IMAGES_DIR = os.path.join(WORKING_DIR, "images")
-if not os.path.exists(IMAGES_DIR):
-    os.mkdir(IMAGES_DIR)
-INFO_DIR = os.path.join(WORKING_DIR, "info")
-if not os.path.exists(INFO_DIR):
-    os.mkdir(INFO_DIR)
+
+IMAGES_CACHE_DIR = os.path.join(WORKING_DIR, "images")
+if not os.path.exists(IMAGES_CACHE_DIR):
+    os.mkdir(IMAGES_CACHE_DIR)
+ANIME_INFO_CACHE_DIR = os.path.join(WORKING_DIR, "info")
+if not os.path.exists(ANIME_INFO_CACHE_DIR):
+    os.mkdir(ANIME_INFO_CACHE_DIR)
 
 
 def save_image_from_url(url: str, file_name: str):
+    """Helper function that downloads an image to the FastAnime images cache dir given its url and filename
+
+    Args:
+        url: image url to download
+        file_name: filename to use
+    """
     image = requests.get(url)
-    with open(f"{IMAGES_DIR}/{file_name}", "wb") as f:
+    with open(f"{IMAGES_CACHE_DIR}/{file_name}", "wb") as f:
         f.write(image.content)
 
 
 def save_info_from_str(info: str, file_name: str):
-    with open(f"{INFO_DIR}/{file_name}", "w") as f:
+    """Helper function that writes text (anime details and info) to a file given  its filename
+
+    Args:
+        info: the information anilist has on the anime
+        file_name: the filename to use
+    """
+    with open(f"{ANIME_INFO_CACHE_DIR}/{file_name}", "w") as f:
         f.write(info)
 
 
 def write_search_results(
-    search_results: list[AnilistBaseMediaDataSchema],
-    titles,
-    workers=None,
+    anilist_results: list[AnilistBaseMediaDataSchema],
+    titles: list[str],
+    workers: int | None = None,
 ):
-    H_COLOR = 215, 0, 95
-    S_COLOR = 208, 208, 208
-    S_WIDTH = 45
+    """A helper function used by and run in a background thread by get_fzf_preview function inorder to get the actual preview data to be displayed by fzf
+
+    Args:
+        anilist_results: the anilist results from an anilist action
+        titles: sanitized anime titles
+        workers:number of threads to use defaults to as many as possible
+    """
+    # NOTE: Will probably make this a configuraable option
+    HEADER_COLOR = 215, 0, 95
+    SEPARATOR_COLOR = 208, 208, 208
+    SEPARATOR_WIDTH = 45
+    # use concurency to download and write as fast as possible
     with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
         future_to_task = {}
-        for anime, title in zip(search_results, titles):
+        for anime, title in zip(anilist_results, titles):
+            # actual image url
             image_url = anime["coverImage"]["large"]
             future_to_task[executor.submit(save_image_from_url, image_url, title)] = (
                 image_url
@@ -149,19 +184,19 @@ def write_search_results(
 
             # handle the text data
             template = f"""
-            {get_true_fg("-"*S_WIDTH,*S_COLOR,bold=False)}
-            {get_true_fg('Title(jp):',*H_COLOR)} {anime['title']['romaji']}
-            {get_true_fg('Title(eng):',*H_COLOR)} {anime['title']['english']}
-            {get_true_fg('Popularity:',*H_COLOR)} {anime['popularity']}
-            {get_true_fg('Favourites:',*H_COLOR)} {anime['favourites']}
-            {get_true_fg('Status:',*H_COLOR)} {anime['status']}
-            {get_true_fg('Episodes:',*H_COLOR)} {anime['episodes']}
-            {get_true_fg('Genres:',*H_COLOR)} {anilist_data_helper.format_list_data_with_comma(anime['genres'])}
-            {get_true_fg('Next Episode:',*H_COLOR)} {anilist_data_helper.extract_next_airing_episode(anime['nextAiringEpisode'])}
-            {get_true_fg('Start Date:',*H_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['startDate'])}
-            {get_true_fg('End Date:',*H_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['endDate'])}
-            {get_true_fg("-"*S_WIDTH,*S_COLOR,bold=False)}
-            {get_true_fg('Description:',*H_COLOR)}
+            {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
+            {get_true_fg('Title(jp):',*HEADER_COLOR)} {anime['title']['romaji']}
+            {get_true_fg('Title(eng):',*HEADER_COLOR)} {anime['title']['english']}
+            {get_true_fg('Popularity:',*HEADER_COLOR)} {anime['popularity']}
+            {get_true_fg('Favourites:',*HEADER_COLOR)} {anime['favourites']}
+            {get_true_fg('Status:',*HEADER_COLOR)} {anime['status']}
+            {get_true_fg('Episodes:',*HEADER_COLOR)} {anime['episodes']}
+            {get_true_fg('Genres:',*HEADER_COLOR)} {anilist_data_helper.format_list_data_with_comma(anime['genres'])}
+            {get_true_fg('Next Episode:',*HEADER_COLOR)} {anilist_data_helper.extract_next_airing_episode(anime['nextAiringEpisode'])}
+            {get_true_fg('Start Date:',*HEADER_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['startDate'])}
+            {get_true_fg('End Date:',*HEADER_COLOR)} {anilist_data_helper.format_anilist_date_object(anime['endDate'])}
+            {get_true_fg("-"*SEPARATOR_WIDTH,*SEPARATOR_COLOR,bold=False)}
+            {get_true_fg('Description:',*HEADER_COLOR)}
             """
             template = textwrap.dedent(template)
             template = f"""
@@ -181,11 +216,22 @@ def write_search_results(
 
 
 # get rofi icons
-def get_icons(search_results: list[AnilistBaseMediaDataSchema], titles, workers=None):
+def get_rofi_icons(
+    anilist_results: list[AnilistBaseMediaDataSchema], titles, workers=None
+):
+    """A helper function to make sure that the images are downloaded so they can be used as icons
+
+    Args:
+        titles (list[str]): sanitized titles of the anime; NOTE: its important that they are sanitized since they are used as the filenames of the images
+        workers ([TODO:parameter]): Number of threads to use to download the images; defaults to as many as possible
+        anilist_results: the anilist results from an anilist action
+    """
+    # use concurrency to download the images as fast as possible
     with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
         # load the jobs
         future_to_url = {}
-        for anime, title in zip(search_results, titles):
+        for anime, title in zip(anilist_results, titles):
+            # actual link to download image from
             image_url = anime["coverImage"]["large"]
             future_to_url[executor.submit(save_image_from_url, image_url, title)] = (
                 image_url
@@ -196,19 +242,32 @@ def get_icons(search_results: list[AnilistBaseMediaDataSchema], titles, workers=
             url = future_to_url[future]
             try:
                 future.result()
-            except Exception as exc:
-                logger.error("%r generated an exception: %s" % (url, exc))
+            except Exception as e:
+                logger.error("%r generated an exception: %s" % (url, e))
 
 
-def get_preview(search_results: list[AnilistBaseMediaDataSchema], titles, wait=False):
+def get_fzf_preview(
+    anilist_results: list[AnilistBaseMediaDataSchema], titles, wait=False
+):
+    """A helper function that constructs data to be used for the fzf preview
+
+    Args:
+        titles (list[str]): The sanitized titles to use, NOTE: its important that they are sanitized since thay will be used as filenames
+        wait (bool): whether to block the ui as we wait for preview defaults to false
+        anilist_results: the anilist results got from an anilist action
+
+    Returns:
+        THe fzf preview script to use
+    """
     # ensure images and info exists
     background_worker = Thread(
-        target=write_search_results, args=(search_results, titles)
+        target=write_search_results, args=(anilist_results, titles)
     )
     background_worker.daemon = True
     background_worker.start()
 
-    os.environ["SHELL"] = shutil.which("bash") or "sh"
+    # the preview script is in bash so making sure fzf doesnt use any other shell lang to process the preview script
+    os.environ["SHELL"] = shutil.which("bash") or "bash"
     preview = """
         %s
         if [ -s %s/{} ]; then fzf-preview %s/{}
@@ -219,12 +278,11 @@ def get_preview(search_results: list[AnilistBaseMediaDataSchema], titles, wait=F
         fi
     """ % (
         fzf_preview,
-        IMAGES_DIR,
-        IMAGES_DIR,
-        INFO_DIR,
-        INFO_DIR,
+        IMAGES_CACHE_DIR,
+        IMAGES_CACHE_DIR,
+        ANIME_INFO_CACHE_DIR,
+        ANIME_INFO_CACHE_DIR,
     )
-    # preview.replace("\n", ";")
     if wait:
         background_worker.join()
     return preview

fastanime/cli/utils/player.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING
 import mpv
 
 from ...anilist import AniList
+from .utils import filter_by_quality
 
 if TYPE_CHECKING:
     from typing import Literal
@@ -27,6 +28,7 @@ class MpvPlayer(object):
     last_stop_time_secs = 0
     last_total_time_secs = 0
     current_media_title = ""
+    player_fetching = False
 
     def get_episode(
         self,
@@ -34,13 +36,17 @@ class MpvPlayer(object):
         ep_no=None,
         server="top",
     ):
-        anilist_config = self.anilist_config
+        fastanime_runtime_state = self.fastanime_runtime_state
         config = self.config
-        episode_number: str = anilist_config.episode_number
+        current_episode_number: str = (
+            fastanime_runtime_state.provider_current_episode_number
+        )
         quality = config.quality
-        episodes: list = sorted(anilist_config.episodes, key=float)
-        anime_id: int = anilist_config.anime_id
-        anime = anilist_config.anime
+        total_episodes: list = sorted(
+            fastanime_runtime_state.provider_available_episodes, key=float
+        )
+        anime_id_anilist: int = fastanime_runtime_state.selected_anime_id_anilist
+        provider_anime = fastanime_runtime_state.provider_anime
         translation_type = config.translation_type
         anime_provider = config.anime_provider
         self.last_stop_time: str = "0"
@@ -51,51 +57,59 @@ class MpvPlayer(object):
         # next or prev
         if type == "next":
             self.mpv_player.show_text("Fetching next episode...")
-            next_episode = episodes.index(episode_number) + 1
-            if next_episode >= len(episodes):
-                next_episode = len(episodes) - 1
-            anilist_config.episode_number = episodes[next_episode]
-            episode_number = anilist_config.episode_number
-            config.update_watch_history(anime_id, str(episode_number))
+            next_episode = total_episodes.index(current_episode_number) + 1
+            if next_episode >= len(total_episodes):
+                next_episode = len(total_episodes) - 1
+            fastanime_runtime_state.provider_current_episode_number = total_episodes[
+                next_episode
+            ]
+            current_episode_number = (
+                fastanime_runtime_state.provider_current_episode_number
+            )
+            config.update_watch_history(anime_id_anilist, str(current_episode_number))
         elif type == "reload":
-            if episode_number not in episodes:
+            if current_episode_number not in total_episodes:
                 self.mpv_player.show_text("Episode not available")
                 return
             self.mpv_player.show_text("Replaying Episode...")
         elif type == "custom":
-            if not ep_no or ep_no not in episodes:
+            if not ep_no or ep_no not in total_episodes:
                 self.mpv_player.show_text("Episode number not specified or invalid")
                 self.mpv_player.show_text(
-                    f"Acceptable episodes are:  {episodes}",
+                    f"Acceptable episodes are:  {total_episodes}",
                 )
                 return
 
             self.mpv_player.show_text(f"Fetching episode {ep_no}")
-            episode_number = ep_no
-            config.update_watch_history(anime_id, str(ep_no))
-            anilist_config.episode_number = str(ep_no)
+            current_episode_number = ep_no
+            config.update_watch_history(anime_id_anilist, str(ep_no))
+            fastanime_runtime_state.provider_current_episode_number = str(ep_no)
         else:
             self.mpv_player.show_text("Fetching previous episode...")
-            prev_episode = episodes.index(episode_number) - 1
+            prev_episode = total_episodes.index(current_episode_number) - 1
             if prev_episode <= 0:
                 prev_episode = 0
-            anilist_config.episode_number = episodes[prev_episode]
-            episode_number = anilist_config.episode_number
-            config.update_watch_history(anime_id, str(episode_number))
+            fastanime_runtime_state.provider_current_episode_number = total_episodes[
+                prev_episode
+            ]
+            current_episode_number = (
+                fastanime_runtime_state.provider_current_episode_number
+            )
+            config.update_watch_history(anime_id_anilist, str(current_episode_number))
         # update episode progress
-        if config.user and episode_number:
+        if config.user and current_episode_number:
             AniList.update_anime_list(
                 {
-                    "mediaId": anime_id,
-                    "progress": episode_number,
+                    "mediaId": anime_id_anilist,
+                    "progress": current_episode_number,
                 }
             )
         # get them juicy streams
         episode_streams = anime_provider.get_episode_streams(
-            anime,
-            episode_number,
+            provider_anime,
+            current_episode_number,
             translation_type,
-            anilist_config.selected_anime_anilist,
+            fastanime_runtime_state.selected_anime_anilist,
         )
         if not episode_streams:
             self.mpv_player.show_text("No streams were found")
@@ -117,23 +131,24 @@ class MpvPlayer(object):
                 return None
         self.current_media_title = selected_server["episode_title"]
         links = selected_server["links"]
-        if quality > len(links) - 1:
-            quality = config.quality = len(links) - 1
-        elif quality < 0:
-            quality = config.quality = 0
-        stream_link = links[quality]["link"]
+
+        stream_link_ = filter_by_quality(quality, links)
+        if not stream_link_:
+            self.mpv_player.show_text("Quality not found")
+            return
+        stream_link = stream_link_["link"]
         return stream_link
 
     def create_player(
         self,
         stream_link,
         anime_provider: "AnimeProvider",
-        anilist_config,
+        fastanime_runtime_state,
         config: "Config",
         title,
     ):
         self.anime_provider = anime_provider
-        self.anilist_config = anilist_config
+        self.fastanime_runtime_state = fastanime_runtime_state
         self.config = config
         self.last_stop_time: str = "0"
         self.last_total_time: str = "0"
@@ -148,6 +163,7 @@ class MpvPlayer(object):
             input_default_bindings=True,
             input_vo_keyboard=True,
             osc=True,
+            ytdl=True,
         )
         mpv_player.force_window = config.force_window
         # mpv_player.cache = "yes"
@@ -160,6 +176,7 @@ class MpvPlayer(object):
         @mpv_player.event_callback("file-loaded")
         def set_total_time(event, *args):
             d = mpv_player._get_property("duration")
+            self.player_fetching = False
             if isinstance(d, float):
                 self.last_total_time = format_time(d)
 
@@ -171,17 +188,19 @@ class MpvPlayer(object):
                     self.last_stop_time = format_time(value)
 
         @mpv_player.property_observer("time-remaining")
-        def handle_time_remaining_update(*args):
-            if len(args) > 1:
-                value = args[1]
-                if value is not None:
-                    if value < 10 and config.auto_next:
-                        url = self.get_episode("next")
-                        if url:
-                            mpv_player.loadfile(
-                                url,
-                            )
-                            mpv_player.title = self.current_media_title
+        def handle_time_remaining_update(
+            property, time_remaining: float | None = None, *args
+        ):
+            if time_remaining is not None:
+                if time_remaining < 1 and config.auto_next and not self.player_fetching:
+                    print("Auto Fetching Next Episode")
+                    self.player_fetching = True
+                    url = self.get_episode("next")
+                    if url:
+                        mpv_player.loadfile(
+                            url,
+                        )
+                        mpv_player.title = self.current_media_title
 
         # -- keybindings --
         @mpv_player.on_key_press("shift+n")
@@ -212,13 +231,15 @@ class MpvPlayer(object):
         def _toggle_translation_type():
             translation_type = "sub" if config.translation_type == "dub" else "dub"
             anime = anime_provider.get_anime(
-                anilist_config._anime["id"],
-                anilist_config.selected_anime_anilist,
+                fastanime_runtime_state.provider_anime_search_result["id"],
+                fastanime_runtime_state.selected_anime_anilist,
             )
             if not anime:
                 mpv_player.show_text("Failed to update translation type")
                 return
-            anilist_config.episodes = anime["availableEpisodesDetail"][translation_type]
+            fastanime_runtime_state.provider_available_episodes = anime[
+                "availableEpisodesDetail"
+            ][translation_type]
             config.translation_type = translation_type
 
             if config.translation_type == "dub":
@@ -262,6 +283,27 @@ class MpvPlayer(object):
             else:
                 pass
 
+        @mpv_player.message_handler("select-quality")
+        def select_quality(quality_raw: bytes | None = None, *args):
+            if not quality_raw:
+                mpv_player.show_text("No quality was selected")
+                return
+            q = ["360", "720", "1080"]
+            quality = quality_raw.decode()
+            links: list = fastanime_runtime_state.provider_server_episode_streams
+            q = [link["quality"] for link in links]
+            if quality in q:
+                config.quality = quality
+                stream_link_ = filter_by_quality(quality, links)
+                if not stream_link_:
+                    mpv_player.show_text("Quality not found")
+                    return
+                mpv_player.show_text(f"Changing to stream of quality {quality}")
+                stream_link = stream_link_["link"]
+                mpv_player.loadfile(stream_link)
+            else:
+                mpv_player.show_text(f"invalid quality!! Valid quality includes: {q}")
+
         # -- events --
         mpv_player.observe_property("time-pos", handle_time_start_update)
         mpv_player.observe_property("time-remaining", handle_time_remaining_update)
@@ -270,6 +312,7 @@ class MpvPlayer(object):
         # --script-messages --
         mpv_player.register_message_handler("select-episode", select_episode)
         mpv_player.register_message_handler("select-server", select_server)
+        mpv_player.register_message_handler("select-quality", select_quality)
 
         self.mpv_player = mpv_player
         return mpv_player

fastanime/cli/utils/tools.py

@@ -1,4 +1,4 @@
-class QueryDict(dict):
+class FastAnimeRuntimeState(dict):
     """dot.notation access to dictionary attributes"""
 
     def __getattr__(self, attr):

fastanime/cli/utils/utils.py

@@ -1,4 +1,5 @@
 import logging
+from typing import TYPE_CHECKING
 
 from InquirerPy import inquirer
 from thefuzz import fuzz
@@ -6,7 +7,8 @@ from thefuzz import fuzz
 from ...Utility.data import anime_normalizer
 
 logger = logging.getLogger(__name__)
-
+if TYPE_CHECKING:
+    from ...libs.anime_provider.types import EpisodeStream
 
 # Define ANSI escape codes as constants
 RESET = "\033[0m"
@@ -20,15 +22,52 @@ BG_GREEN = "\033[48;2;120;233;12;m"
 GREEN = "\033[38;2;45;24;45;m"
 
 
-def sizeof_fmt(num, suffix="B"):
+def filter_by_quality(quality: str, stream_links: "list[EpisodeStream]"):
+    """Helper function used to filter a list of EpisodeStream objects to one that has a corresponding quality
+
+    Args:
+        quality: the quality to use
+        stream_links: a list of EpisodeStream objects
+
+    Returns:
+        an EpisodeStream object or None incase the quality was not found
+    """
+    for stream_link in stream_links:
+        if stream_link["quality"] == quality:
+            return stream_link
+
+
+def format_bytes_to_human(num_of_bytes: float, suffix: str = "B"):
+    """Helper function usedd to format bytes to human
+
+    Args:
+        num_of_bytes: the number of bytes to format
+        suffix: the suffix to use
+
+    Returns:
+        formated bytes
+    """
     for unit in ("", "K", "M", "G", "T", "P", "E", "Z"):
-        if abs(num) < 1024.0:
-            return f"{num:3.1f}{unit}{suffix}"
-        num /= 1024.0
-    return f"{num:.1f}Yi{suffix}"
+        if abs(num_of_bytes) < 1024.0:
+            return f"{num_of_bytes:3.1f}{unit}{suffix}"
+        num_of_bytes /= 1024.0
+    return f"{num_of_bytes:.1f}Yi{suffix}"
 
 
-def get_true_fg(string: str, r: int, g: int, b: int, bold=True) -> str:
+def get_true_fg(string: str, r: int, g: int, b: int, bold: bool = True) -> str:
+    """Custom helper function that enables colored text in the terminal
+
+    Args:
+        bold: whether to bolden the text
+        string: string to color
+        r: red
+        g: green
+        b: blue
+
+    Returns:
+        colored string
+    """
+    # NOTE: Currently only supports terminals that support true color
     if bold:
         return f"{BOLD}\033[38;2;{r};{g};{b};m{string}{RESET}"
     else:
@@ -39,7 +78,17 @@ def get_true_bg(string, r: int, g: int, b: int) -> str:
     return f"\033[48;2;{r};{g};{b};m{string}{RESET}"
 
 
-def fuzzy_inquirer(prompt: str, choices, **kwargs):
+def fuzzy_inquirer(choices: list, prompt: str, **kwargs):
+    """helper function that enables easier interaction with InquirerPy lib
+
+    Args:
+        choices: the choices to prompt
+        prompt: the prompt string to use
+        **kwargs: other options to pass to fuzzy_inquirer
+
+    Returns:
+        a choice
+    """
     from click import clear
 
     clear()
@@ -54,6 +103,7 @@ def fuzzy_inquirer(prompt: str, choices, **kwargs):
     return action
 
 
+# WARNING: This function is depracated use the one from the main utility package
 def anime_title_percentage_match(
     possible_user_requested_anime_title: str, title: tuple
 ) -> float:

fastanime/libs/anilist/api.py

@@ -29,7 +29,7 @@ from .queries_graphql import (
 )
 
 if TYPE_CHECKING:
-    from .anilist_data_schema import (
+    from .types import (
         AnilistDataSchema,
         AnilistMediaLists,
         AnilistMediaListStatus,
@@ -126,7 +126,9 @@ class AniListApi:
         return self._make_authenticated_request(media_list_mutation, variables)
 
     def get_anime_list(
-        self, status: "AnilistMediaListStatus"
+        self,
+        status: "AnilistMediaListStatus",
+        type="ANIME",
     ) -> tuple[bool, "AnilistMediaLists"] | tuple[bool, None]:
         """gets an anime list from your media list given the list status
 
@@ -136,7 +138,7 @@ class AniListApi:
         Returns:
             a media list
         """
-        variables = {"status": status, "userId": self.user_id}
+        variables = {"status": status, "userId": self.user_id, "type": type}
         return self._make_authenticated_request(media_list_query, variables)
 
     def get_medialist_entry(
@@ -310,6 +312,7 @@ class AniListApi:
         start_greater: int | None = None,
         start_lesser: int | None = None,
         page: int | None = None,
+        type="ANIME",
         **kwargs,
     ):
         """
@@ -329,65 +332,74 @@ class AniListApi:
         variables = {"id": id}
         return self.get_data(anime_query, variables)
 
-    def get_trending(self, *_, **kwargs):
+    def get_trending(self, type="ANIME", *_, **kwargs):
         """
         Gets the currently trending anime
         """
-        trending = self.get_data(trending_query)
+        variables = {"type": type}
+        trending = self.get_data(trending_query, variables)
         return trending
 
-    def get_most_favourite(self, *_, **kwargs):
+    def get_most_favourite(self, type="ANIME", *_, **kwargs):
         """
         Gets the most favoured anime on anilist
         """
-        most_favourite = self.get_data(most_favourite_query)
+        variables = {"type": type}
+        most_favourite = self.get_data(most_favourite_query, variables)
         return most_favourite
 
-    def get_most_scored(self, *_, **kwargs):
+    def get_most_scored(self, type="ANIME", *_, **kwargs):
         """
         Gets most scored anime on anilist
         """
-        most_scored = self.get_data(most_scored_query)
+        variables = {"type": type}
+        most_scored = self.get_data(most_scored_query, variables)
         return most_scored
 
-    def get_most_recently_updated(self, *_, **kwargs):
+    def get_most_recently_updated(self, type="ANIME", *_, **kwargs):
         """
         Gets most recently updated anime from anilist
         """
-        most_recently_updated = self.get_data(most_recently_updated_query)
+        variables = {"type": type}
+        most_recently_updated = self.get_data(most_recently_updated_query, variables)
         return most_recently_updated
 
-    def get_most_popular(self):
+    def get_most_popular(
+        self,
+        type="ANIME",
+    ):
         """
         Gets most popular anime on anilist
         """
-        most_popular = self.get_data(most_popular_query)
+        variables = {"type": type}
+        most_popular = self.get_data(most_popular_query, variables)
         return most_popular
 
-    def get_upcoming_anime(self, page: int = 1, *_, **kwargs):
+    def get_upcoming_anime(self, type="ANIME", page: int = 1, *_, **kwargs):
         """
         Gets upcoming anime from anilist
         """
-        variables = {"page": page}
+        variables = {"page": page, "type": type}
         upcoming_anime = self.get_data(upcoming_anime_query, variables)
         return upcoming_anime
 
     # NOTE: THe following methods will probably be scraped soon
-    def get_recommended_anime_for(self, id: int, *_, **kwargs):
-        recommended_anime = self.get_data(recommended_query)
+    def get_recommended_anime_for(self, id: int, type="ANIME", *_, **kwargs):
+        variables = {"type": type}
+        recommended_anime = self.get_data(recommended_query, variables)
         return recommended_anime
 
-    def get_charcters_of(self, id: int, *_, **kwargs):
+    def get_charcters_of(self, id: int, type="ANIME", *_, **kwargs):
         variables = {"id": id}
         characters = self.get_data(anime_characters_query, variables)
         return characters
 
-    def get_related_anime_for(self, id: int, *_, **kwargs):
+    def get_related_anime_for(self, id: int, type="ANIME", *_, **kwargs):
         variables = {"id": id}
         related_anime = self.get_data(anime_relations_query, variables)
         return related_anime
 
-    def get_airing_schedule_for(self, id: int, *_, **kwargs):
+    def get_airing_schedule_for(self, id: int, type="ANIME", *_, **kwargs):
         variables = {"id": id}
         airing_schedule = self.get_data(airing_schedule_query, variables)
         return airing_schedule

fastanime/libs/anilist/queries_graphql.py

@@ -122,13 +122,13 @@ mutation($mediaId:Int,$scoreRaw:Int,$repeat:Int,$progress:Int,$status:MediaListS
 """
 
 media_list_query = """
-query ($userId: Int, $status: MediaListStatus) {
+query ($userId: Int, $status: MediaListStatus,$type:MediaType) {
   Page {
     pageInfo {
         currentPage
         total
     }
-    mediaList(userId: $userId, status: $status, type: ANIME) {
+    mediaList(userId: $userId, status: $status, type: $type) {
       mediaId
       
       media {
@@ -223,7 +223,8 @@ $averageScore_lesser:Int,\
 $startDate_greater:FuzzyDateInt,\
 $startDate_lesser:FuzzyDateInt,\
 $endDate_greater:FuzzyDateInt,\
-$endDate_lesser:FuzzyDateInt\
+$endDate_lesser:FuzzyDateInt,\
+$type:MediaType\
 "
 # FuzzyDateInt = (yyyymmdd)
 # MediaStatus = (FINISHED,RELEASING,NOT_YET_RELEASED,CANCELLED,HIATUS)
@@ -255,7 +256,7 @@ query($query:String,%s){
       endDate_greater:$endDate_greater,
       endDate_lesser:$endDate_lesser,
       sort:$sort,
-      type:ANIME
+      type:$type
       )
     {
       id
@@ -316,10 +317,10 @@ query($query:String,%s){
 )
 
 trending_query = """
-query{  
+query($type:MediaType){  
   Page(perPage:15){
     
-    media(sort:TRENDING_DESC,type:ANIME,genre_not_in:["hentai"]){
+    media(sort:TRENDING_DESC,type:$type,genre_not_in:["hentai"]){
       id
         idMal
       title{
@@ -376,9 +377,9 @@ query{
 
 # mosts
 most_favourite_query = """
-query{
+query($type:MediaType){
   Page(perPage:15){    
-    media(sort:FAVOURITES_DESC,type:ANIME,genre_not_in:["hentai"]){
+    media(sort:FAVOURITES_DESC,type:$type,genre_not_in:["hentai"]){
       id
         idMal
       title{
@@ -435,9 +436,9 @@ query{
 """
 
 most_scored_query = """
-query{
+query($type:MediaType){
   Page(perPage:15){
-    media(sort:SCORE_DESC,type:ANIME,genre_not_in:["hentai"]){
+    media(sort:SCORE_DESC,type:$type,genre_not_in:["hentai"]){
       id
         idMal
       title{
@@ -494,9 +495,9 @@ query{
 """
 
 most_popular_query = """
-query{  
+query($type:MediaType){  
   Page(perPage:15){
-    media(sort:POPULARITY_DESC,type:ANIME,genre_not_in:["hentai"]){
+    media(sort:POPULARITY_DESC,type:$type,genre_not_in:["hentai"]){
       id
         idMal
       title{
@@ -553,9 +554,9 @@ query{
 """
 
 most_recently_updated_query = """
-query{
+query($type:MediaType){
   Page(perPage:15){
-    media(sort:UPDATED_AT_DESC,type:ANIME,averageScore_greater:50,genre_not_in:["hentai"],status:RELEASING){
+    media(sort:UPDATED_AT_DESC,type:$type,averageScore_greater:50,genre_not_in:["hentai"],status:RELEASING){
       id
         idMal
       title{
@@ -611,9 +612,9 @@ query{
 """
 
 recommended_query = """
-query  {
+query($type:MediaType){
   Page(perPage:15) {
-    media( type: ANIME,genre_not_in:["hentai"]) {
+    media( type: $type,genre_not_in:["hentai"]) {
       recommendations(sort:RATING_DESC){
         nodes{
           media{
@@ -671,9 +672,9 @@ query  {
 """
 
 anime_characters_query = """
-query($id:Int){
+query($id:Int,$type:MediaType){
   Page {
-    media(id:$id, type: ANIME) {
+    media(id:$id, type: $type) {
       characters {
         nodes {
           name {
@@ -706,9 +707,9 @@ query($id:Int){
 
 
 anime_relations_query = """
-query ($id: Int) {
+query ($id: Int,$type:MediaType) {
   Page(perPage: 20) {
-    media(id: $id, sort: POPULARITY_DESC, type: ANIME,genre_not_in:["hentai"]) {
+    media(id: $id, sort: POPULARITY_DESC, type: $type,genre_not_in:["hentai"]) {
       relations {
         nodes {
           id
@@ -763,9 +764,9 @@ query ($id: Int) {
 """
 
 airing_schedule_query = """
-query ($id: Int) {
+query ($id: Int,$type:MediaType) {
   Page {
-    media(id: $id, sort: POPULARITY_DESC, type: ANIME) {
+    media(id: $id, sort: POPULARITY_DESC, type: $type) {
       airingSchedule(notYetAired:true){
         nodes{
           airingAt
@@ -780,7 +781,7 @@ query ($id: Int) {
 """
 
 upcoming_anime_query = """
-query ($page: Int) {
+query ($page: Int,$type:MediaType) {
   Page(page: $page) {
     pageInfo {
       total
@@ -788,7 +789,7 @@ query ($page: Int) {
       currentPage
       hasNextPage
     }
-    media(type: ANIME, status: NOT_YET_RELEASED,sort:POPULARITY_DESC,genre_not_in:["hentai"]) {
+    media(type: $type, status: NOT_YET_RELEASED,sort:POPULARITY_DESC,genre_not_in:["hentai"]) {
       id
         idMal
       title {

fastanime/libs/anime_provider/__init__.py

@@ -1,5 +1,12 @@
 anime_sources = {
     "allanime": "api.AllAnimeAPI",
     "animepahe": "api.AnimePaheApi",
-    "aniwatch": "api.AniWatchApi",
 }
+SERVERS_AVAILABLE = [
+    "sharepoint",
+    "dropbox",
+    "gogoanime",
+    "weTransfer",
+    "wixmp",
+    "kwik",
+]

fastanime/libs/anime_provider/allanime/api.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 from requests.exceptions import Timeout
 
 from ...anime_provider.base_provider import AnimeProvider
-from ..utils import decode_hex_string
+from ..utils import decode_hex_string, give_random_quality
 from .constants import (
     ALLANIME_API_ENDPOINT,
     ALLANIME_BASE,
@@ -215,7 +215,7 @@ class AllAnimeAPI(AnimeProvider):
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
                                     + f"; Episode {episode_number}",
-                                    "links": resp.json()["links"],
+                                    "links": give_random_quality(resp.json()["links"]),
                                 }  # pyright:ignore
                             case "Kir":
                                 logger.debug("allanime:Found streams from wetransfer")
@@ -225,7 +225,7 @@ class AllAnimeAPI(AnimeProvider):
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
                                     + f"; Episode {episode_number}",
-                                    "links": resp.json()["links"],
+                                    "links": give_random_quality(resp.json()["links"]),
                                 }  # pyright:ignore
                             case "S-mp4":
                                 logger.debug("allanime:Found streams from sharepoint")
@@ -235,7 +235,7 @@ class AllAnimeAPI(AnimeProvider):
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
                                     + f"; Episode {episode_number}",
-                                    "links": resp.json()["links"],
+                                    "links": give_random_quality(resp.json()["links"]),
                                 }  # pyright:ignore
                             case "Sak":
                                 logger.debug("allanime:Found streams from dropbox")
@@ -245,7 +245,7 @@ class AllAnimeAPI(AnimeProvider):
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
                                     + f"; Episode {episode_number}",
-                                    "links": resp.json()["links"],
+                                    "links": give_random_quality(resp.json()["links"]),
                                 }  # pyright:ignore
                             case "Default":
                                 logger.debug("allanime:Found streams from wixmp")
@@ -255,7 +255,7 @@ class AllAnimeAPI(AnimeProvider):
                                         allanime_episode["notes"] or f'{anime["title"]}'
                                     )
                                     + f"; Episode {episode_number}",
-                                    "links": resp.json()["links"],
+                                    "links": give_random_quality(resp.json()["links"]),
                                 }  # pyright:ignore
                 except Timeout:
                     logger.error(

fastanime/libs/anime_provider/allanime/normalizer.py

@@ -1,6 +1,8 @@
-from ..types import Anime, EpisodesDetail, SearchResults
+from ..types import Anime, AnimeEpisodeDetails, SearchResults
 from .types import AllAnimeEpisode, AllAnimeSearchResults, AllAnimeShow
 
+# TODO: scrap this module and do the transformations directly from the provider class
+
 
 def normalize_search_results(search_results: AllAnimeSearchResults) -> SearchResults:
     page_info = search_results["shows"]["pageInfo"]
@@ -15,7 +17,7 @@ def normalize_search_results(search_results: AllAnimeSearchResults) -> SearchRes
         results.append(normalized_result)
 
     normalized_search_results: SearchResults = {
-        "pageInfo": page_info,
+        "pageInfo": page_info,  # pyright:ignore
         "results": results,
     }
 
@@ -25,9 +27,11 @@ def normalize_search_results(search_results: AllAnimeSearchResults) -> SearchRes
 def normalize_anime(anime: AllAnimeShow) -> Anime:
     id: str = anime["_id"]
     title: str = anime["name"]
-    availableEpisodesDetail: EpisodesDetail = anime["availableEpisodesDetail"]
+    availableEpisodesDetail: AnimeEpisodeDetails = anime[
+        "availableEpisodesDetail"
+    ]  # pyright:ignore
     type = anime.get("__typename")
-    normalized_anime: Anime = {
+    normalized_anime: Anime = {  # pyright:ignore
         "id": id,
         "title": title,
         "availableEpisodesDetail": availableEpisodesDetail,

fastanime/libs/anime_provider/animepahe/api.py

@@ -1,63 +1,214 @@
-import requests
+import logging
+import re
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
 
-from .constants import ANIMEPAHE_BASE, ANIMEPAHE_ENDPOINT, REQUEST_HEADERS
+from yt_dlp.utils import (
+    extract_attributes,
+    get_element_by_id,
+    get_element_text_and_html_by_tag,
+    get_elements_html_by_class,
+)
+
+from ..base_provider import AnimeProvider
+from .constants import (
+    ANIMEPAHE_BASE,
+    ANIMEPAHE_ENDPOINT,
+    REQUEST_HEADERS,
+    SERVER_HEADERS,
+)
+
+if TYPE_CHECKING:
+    from ..types import Anime
+    from .types import AnimePaheAnimePage, AnimePaheSearchPage, AnimeSearchResult
+JUICY_STREAM_REGEX = re.compile(r"source='(.*)';")
+logger = logging.getLogger(__name__)
 
 
 # TODO: hack this to completion
-class AnimePaheApi:
-    def search_for_anime(self, user_query, *args):
+class AnimePaheApi(AnimeProvider):
+    search_page: "AnimePaheSearchPage"
+    anime: "AnimePaheAnimePage"
+
+    def search_for_anime(self, user_query: str, *args):
         try:
             url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
             headers = {**REQUEST_HEADERS}
-            response = requests.get(url, headers=headers)
+            response = self.session.get(url, headers=headers)
             if not response.status_code == 200:
                 return
-            data = response.json()
+            data: "AnimePaheSearchPage" = response.json()
+            self.search_page = data
+
             return {
-                "pageInfo": {"total": data["total"]},
+                "pageInfo": {
+                    "total": data["total"],
+                    "perPage": data["per_page"],
+                    "currentPage": data["current_page"],
+                },
                 "results": [
                     {
+                        "availableEpisodes": list(range(result["episodes"])),
                         "id": result["session"],
                         "title": result["title"],
-                        "availableEpisodes": result["episodes"],
                         "type": result["type"],
+                        "year": result["year"],
+                        "score": result["score"],
+                        "status": result["status"],
+                        "season": result["season"],
+                        "poster": result["poster"],
                     }
                     for result in data["data"]
                 ],
             }
 
         except Exception as e:
-            print(e)
-            input()
+            logger.error(f"AnimePahe(search): {e}")
+            return {}
 
     def get_anime(self, session_id: str, *args):
-        url = "https://animepahe.ru/api?m=release&id=&sort=episode_asc&page=1"
-        url = f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page=1"
-        response = requests.get(url, headers=REQUEST_HEADERS)
-        if not response.status_code == 200:
-            return
-        data = response.json()
-        self.current = data
-        episodes = list(map(str, range(data["total"])))
-        return {
-            "id": session_id,
-            "title": "none",
-            "availableEpisodesDetail": {
-                "sub": episodes,
-                "dub": episodes,
-                "raw": episodes,
-            },
-        }
+        try:
+            anime_result: "AnimeSearchResult" = [
+                anime
+                for anime in self.search_page["data"]
+                if anime["session"] == session_id
+            ][0]
+            url = (
+                f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page=1"
+            )
+            response = self.session.get(url, headers=REQUEST_HEADERS)
+            if not response.status_code == 200:
+                return {}
+            data: "AnimePaheAnimePage" = response.json()
+            self.anime = data
+            episodes = list(map(str, range(data["total"])))
+            title = ""
+            return {
+                "id": session_id,
+                "title": anime_result["title"],
+                "year": anime_result["year"],
+                "season": anime_result["season"],
+                "poster": anime_result["poster"],
+                "score": anime_result["score"],
+                "availableEpisodesDetail": {
+                    "sub": episodes,
+                    "dub": episodes,
+                    "raw": episodes,
+                },
+                "episodesInfo": [
+                    {
+                        "title": episode["title"] or f"{title};{episode['episode']}",
+                        "episode": episode["episode"],
+                        "id": episode["session"],
+                        "translation_type": episode["audio"],
+                        "duration": episode["duration"],
+                        "poster": episode["snapshot"],
+                    }
+                    for episode in data["data"]
+                ],
+            }
+        except Exception as e:
+            logger.error(f"AnimePahe(anime): {e}")
+            return {}
+
+    def get_episode_streams(
+        self, anime: "Anime", episode_number: str, translation_type, *args
+    ):
+        # extract episode details from memory
+        episode = [
+            episode
+            for episode in self.anime["data"]
+            if float(episode["episode"]) == float(episode_number)
+        ]
+        if not episode:
+            logger.error(f"AnimePahe(streams): episode {episode_number} doesn't exist")
+            raise Exception("Episode not found")
+        episode = episode[0]
 
-    def get_episode_streams(self, anime, episode, *args):
-        episode_id = self.current["data"][int(episode)]["session"]
         anime_id = anime["id"]
-        url = f"{ANIMEPAHE_BASE}play/{anime_id}{episode_id}"
-        response = requests.get(url, headers=REQUEST_HEADERS)
-        print(response.status_code)
-        input()
-        if not response.status_code == 200:
-            print(response.text)
-            return
-        print(response.text)
-        input()
+        # fetch the episode page
+        url = f"{ANIMEPAHE_BASE}/play/{anime_id}/{episode['session']}"
+        response = self.session.get(url, headers=REQUEST_HEADERS)
+        # 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)
+        # convert the elements containing embed links to a neat dict containing:
+        # data-src
+        # data-audio
+        # data-resolution
+        res_dicts = [extract_attributes(item) for item in resolutionMenuItems]
+
+        # get the episode title
+        episode_title = (
+            episode["title"] or f"{anime['title']}; Episode {episode['episode']}"
+        )
+        # get all links
+        streams = {"server": "kwik", "links": [], "episode_title": episode_title}
+        for res_dict in res_dicts:
+            # get embed url
+            embed_url = res_dict["data-src"]
+            data_audio = "dub" if res_dict["data-audio"] == "eng" else "sub"
+            # filter streams by translation_type
+            if data_audio != translation_type:
+                continue
+
+            if not embed_url:
+                logger.warn(
+                    "AnimePahe: embed url not found please report to the developers"
+                )
+                raise Exception("Episode not found")
+            # get embed page
+            embed_response = self.session.get(embed_url, headers=SERVER_HEADERS)
+            embed = embed_response.text
+            # search for the encoded js
+            encoded_js = None
+            for _ in range(7):
+                content, html = get_element_text_and_html_by_tag("script", embed)
+                if not content:
+                    embed = embed.replace(html, "")
+                    continue
+                encoded_js = content
+                break
+            if not encoded_js:
+                logger.warn(
+                    "AnimePahe: Encoded js not found please report to the developers"
+                )
+                raise Exception("Episode not found")
+            # execute the encoded js with node for now or maybe forever in odrder to get a more workable info
+            NODE = shutil.which("node")
+            if not NODE:
+                logger.warn(
+                    "AnimePahe: animepahe currently requires node js to extract them juicy streams"
+                )
+                raise Exception("Episode not found")
+            result = subprocess.run(
+                [NODE, "-e", encoded_js],
+                text=True,
+                capture_output=True,
+            )
+            # decoded js
+            evaluted_js = result.stderr
+            if not evaluted_js:
+                logger.warn(
+                    "AnimePahe: could not decode encoded js using node please report to developers"
+                )
+                raise Exception("Episode not found")
+            # get that juicy stream
+            match = JUICY_STREAM_REGEX.search(evaluted_js)
+            if not match:
+                logger.warn(
+                    "AnimePahe: could not find the juicy stream please report to developers"
+                )
+                raise Exception("Episode not found")
+            # get the actual hls stream link
+            juicy_stream = match.group(1)
+            # add the link
+            streams["links"].append(
+                {
+                    "quality": res_dict["data-resolution"],
+                    "translation_type": data_audio,
+                    "link": juicy_stream,
+                }
+            )
+        yield streams

fastanime/libs/anime_provider/animepahe/constants.py

@@ -2,7 +2,7 @@ from yt_dlp.utils.networking import random_user_agent
 
 USER_AGENT = random_user_agent()
 ANIMEPAHE = "animepahe.ru"
-ANIMEPAHE_BASE = f"https://{ANIMEPAHE}/"
+ANIMEPAHE_BASE = f"https://{ANIMEPAHE}"
 ANIMEPAHE_ENDPOINT = f"{ANIMEPAHE_BASE}/api?"
 
 REQUEST_HEADERS = {
@@ -20,3 +20,20 @@ REQUEST_HEADERS = {
     "Sec-Fetch-Mode": "cors",
     "TE": "trailers",
 }
+SERVER_HEADERS = {
+    "User-Agent": USER_AGENT,
+    "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",
+    "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",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "iframe",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "cross-site",
+    "Sec-Fetch-User": "?1",
+    "Priority": "u=4",
+}

fastanime/libs/anime_provider/animepahe/types.py

@@ -0,0 +1,61 @@
+from typing import Literal, TypedDict
+
+
+class AnimeSearchResult(TypedDict):
+    id: int
+    title: str
+    type: str
+    episodes: int
+    status: str
+    season: str
+    year: int
+    score: int
+    poster: str
+    session: str
+
+
+class AnimePaheSearchPage(TypedDict):
+    total: int
+    per_page: int
+    current_page: int
+    last_page: int
+    _from: int
+    to: int
+    data: list[AnimeSearchResult]
+
+
+class Episode(TypedDict):
+    id: int
+    anime_id: int
+    episode: int
+    episode2: int
+    edition: str
+    title: str
+    snapshot: str  # episode image
+    disc: str
+    audio: Literal["eng", "jpn"]
+    duration: str  # time 00:00:00
+    session: str
+    filler: int
+    created_at: str
+
+
+class AnimePaheAnimePage(TypedDict):
+    total: int
+    per_page: int
+    current_page: int
+    last_page: int
+    next_page_url: str | None
+    prev_page_url: str | None
+    _from: int
+    to: int
+    data: list[Episode]
+
+
+class Server:
+    type: str
+    data_src = "https://kwik.si/e/PImJ0u7Y3M0G"
+    data_fansub: str
+    data_resolution: Literal["360", "720", "1080"]
+    data_audio: Literal["eng", "jpn"]
+    data_av1: str

fastanime/libs/anime_provider/aniwatch/api.py

@@ -1,49 +0,0 @@
-from ...anilist.anilist_data_schema import AnilistBaseMediaDataSchema
-from ..base_provider import AnimeProvider
-
-"""
-"Zoro": {
-    "27": {
-        "identifier": "27",
-        "image": "https://cdn.noitatnemucod.net/thumbnail/300x400/100/ce5e539af63e42431621fc66a47fbec1.jpg",
-        "malId": 1,
-        "aniId": 1,
-        "page": "Zoro",
-        "title": "Cowboy Bebop",
-        "type": "anime",
-        "url": "https://hianime.to/cowboy-bebop-27"
-    }
-},
-
-episode info =  https://hianime.to/ajax/v2/episode/list/27
-"""
-
-
-# TODO: complete this
-class AniWatchApi(AnimeProvider):
-    def search_for_anime(
-        self, anilist_selected_anime: AnilistBaseMediaDataSchema, *args
-    ):
-        return {
-            "pageInfo": 1,
-            "results": [
-                {
-                    "id": anilist_selected_anime["id"],
-                    "title": anilist_selected_anime["title"],
-                    "availableEpisodes": [],
-                }
-            ],
-        }
-
-    def get_anime(self, id: int):
-        url = f"https://raw.githubusercontent.com/bal-mackup/mal-backup/master/anilist/anime/{id}.json"
-        response = self.session.get(url)
-        if response.status_code == 200:
-            data = response.json()
-            data["Sites"]["Zoro"]
-            return {"id": ""}
-        else:
-            return {}
-
-    def get_episode_streams(self, id: int, episode: str, translation_type: str):
-        pass

fastanime/libs/anime_provider/types.py

@@ -1,8 +1,18 @@
-from typing import TypedDict
+from typing import Literal, TypedDict
 
 
 class PageInfo(TypedDict):
     total: int
+    perPage: int
+    currentPage: int
+
+
+#
+# class EpisodesDetail(TypedDict):
+#     dub: int
+#     sub: int
+#     raw: int
+#
 
 
 # search data
@@ -11,6 +21,10 @@ class SearchResult(TypedDict):
     title: str
     availableEpisodes: list[str]
     type: str
+    score: int
+    status: str
+    season: str
+    poster: str
 
 
 class SearchResults(TypedDict):
@@ -19,30 +33,39 @@ class SearchResults(TypedDict):
 
 
 # anime data
-class EpisodesDetail(TypedDict):
-    dub: int
-    sub: int
-    raw: int
+class AnimeEpisodeDetails(TypedDict):
+    dub: list[str]
+    sub: list[str]
+    raw: list[str]
+
+
+class AnimeEpisode(TypedDict):
+    id: str
+    title: str
 
 
 class Anime(TypedDict):
     id: str
     title: str
-    availableEpisodesDetail: EpisodesDetail
+    availableEpisodesDetail: AnimeEpisodeDetails
     type: str | None
+    episodesInfo: list[AnimeEpisode] | None
+    poster: str
+    year: str
 
 
 class EpisodeStream(TypedDict):
-    resolution: str
+    resolution: str | None
     link: str
     hls: bool | None
-    mp4: bool
-    priority: int
-    headers: dict
-    fromCache: str
+    mp4: bool | None
+    priority: int | None
+    headers: dict | None
+    quality: Literal["360", "720", "1080", "unknown"]
+    translation_type: Literal["dub", "sub"]
 
 
 class Server(TypedDict):
     server: str
     episode_title: str | None
-    links: list
+    links: list[EpisodeStream]

fastanime/libs/anime_provider/utils.py

@@ -1,4 +1,5 @@
 import re
+from itertools import cycle
 
 # Dictionary to map hex values to characters
 hex_to_char = {
@@ -34,6 +35,15 @@ hex_to_char = {
 }
 
 
+def give_random_quality(links: list[dict]):
+    qualities = cycle(["1080", "720", "360"])
+
+    return [
+        {"link": link["link"], "quality": quality}
+        for link, quality in zip(links, qualities)
+    ]
+
+
 def decode_hex_string(hex_string):
     """some of the sources encrypt the urls into hex codes this function decrypts the urls
 

fastanime/libs/fzf/__init__.py

@@ -6,7 +6,6 @@ import sys
 from typing import Callable, List
 
 # TODO: will probably scrap art not to useful
-from art import text2art
 from click import clear
 from rich import print
 
@@ -22,6 +21,17 @@ FZF_DEFAULT_OPTS = """
     --marker=">" --pointer="◆" --separator="─" --scrollbar="│"
 """
 
+HEADER = """
+
+███████╗░█████╗░░██████╗████████╗░█████╗░███╗░░██╗██╗███╗░░░███╗███████╗
+██╔════╝██╔══██╗██╔════╝╚══██╔══╝██╔══██╗████╗░██║██║████╗░████║██╔════╝
+█████╗░░███████║╚█████╗░░░░██║░░░███████║██╔██╗██║██║██╔████╔██║█████╗░░
+██╔══╝░░██╔══██║░╚═══██╗░░░██║░░░██╔══██║██║╚████║██║██║╚██╔╝██║██╔══╝░░
+██║░░░░░██║░░██║██████╔╝░░░██║░░░██║░░██║██║░╚███║██║██║░╚═╝░██║███████╗
+╚═╝░░░░░╚═╝░░╚═╝╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚══╝╚═╝╚═╝░░░░░╚═╝╚══════╝
+
+"""
+
 
 class FZF:
     """an abstraction over the fzf commandline utility
@@ -128,7 +138,7 @@ class FZF:
         self,
         fzf_input: list[str],
         prompt: str,
-        header: str,
+        header: str = HEADER,
         preview: str | None = None,
         expect: str | None = None,
         validator: Callable | None = None,
@@ -149,7 +159,7 @@ class FZF:
         _commands = [
             *self.default_options,
             "--header",
-            text2art(header),
+            HEADER,
             "--header-first",
             "--prompt",
             prompt.title(),

poetry.lock

@@ -1,19 +1,5 @@
 # This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
 
-[[package]]
-name = "art"
-version = "6.2"
-description = "ASCII Art Library For Python"
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "art-6.2-py3-none-any.whl", hash = "sha256:d632d1d3f5fabcaf8673abe934b51df0017bc914d106e89d45ae4ebef0e3149a"},
-    {file = "art-6.2.tar.gz", hash = "sha256:506a0c4f261289a0e0d088de7beffcb1835078c4e44b0c5353bdaf47b490e76f"},
-]
-
-[package.extras]
-dev = ["bandit (>=1.5.1)", "coverage (>=4.1)", "pydocstyle (>=3.0.0)", "vulture (>=1.0)"]
-
 [[package]]
 name = "autoflake"
 version = "2.3.1"
@@ -1421,4 +1407,4 @@ test = ["pytest (>=8.1,<9.0)"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "5305621bc02d824065519913f0d754e269f1e4525ba8796be08504120614259d"
+content-hash = "83ec7de7d9466dcd1fadef4b21eec2a879cc9a7d526992ed280b6af53b49d9f1"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastanime"
-version = "0.60.3.dev1"
+version = "0.62.5.dev1"
 description = "A browser anime site experience from the terminal"
 authors = ["Benextempest <benextempest@gmail.com>"]
 license = "UNLICENSE"
@@ -13,7 +13,6 @@ rich = "^13.7.1"
 click = "^8.1.7"
 inquirerpy = "^0.3.4"
 platformdirs = "^4.2.2"
-art = "^6.2"
 python-dotenv = "^1.0.1"
 thefuzz = "^0.22.1"
 requests = "^2.32.3"

tests/test_all_commands.py

@@ -45,6 +45,16 @@ def test_search_help(runner: CliRunner):
     assert result.exit_code == 0
 
 
+def test_cache_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["cache", "--help"])
+    assert result.exit_code == 0
+
+
+def test_completions_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["completions", "--help"])
+    assert result.exit_code == 0
+
+
 def test_anilist_help(runner: CliRunner):
     result = runner.invoke(run_cli, ["anilist", "--help"])
     assert result.exit_code == 0