docs: updaate readme

This reverts commit 571ab488f8.

README.md

@@ -2,18 +2,20 @@
 
 Welcome to **FastAnime**, anime site experience from the terminal.
 
+![fastanime-demo](https://github.com/user-attachments/assets/16e29f54-e9fa-48c7-b944-bfacb31ae1b5)
 
-**fzf mode**
-
+<details>
+<summary><b>fzf mode</b></summary>
+  
 [fa_fzf_demo.webm](https://github.com/user-attachments/assets/b1fecf25-e358-4e8b-a144-bcb7947210cf)
 
-
-**other modes:**
+</details>
 
 <details>
 <summary><b>rofi mode</b></summary>
 
 [fa_rofi_mode.webm](https://github.com/user-attachments/assets/2ce669bf-b62f-4c44-bd79-cf0dcaddf37a)
+
 </details>
 
 <details>
@@ -23,11 +25,8 @@ Welcome to **FastAnime**, anime site experience from the terminal.
 
 </details>
 
-
 Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magic-tape](https://gitlab.com/christosangel/magic-tape/-/tree/main?ref_type=heads) and [ani-cli](https://github.com/pystardust/ani-cli).
 
-
-
 <!--toc:start-->
 
 - [FastAnime](#fastanime)
@@ -40,13 +39,20 @@ Heavily inspired by [animdl](https://github.com/justfoolingaround/animdl), [magi
     - [External Dependencies](#external-dependencies)
   - [Usage](#usage)
     - [The Commandline interface :fire:](#the-commandline-interface-fire)
-      - [The anilist command](#the-anilist-command)
+      - [The anilist command :fire: :fire: :fire:](#the-anilist-command-fire-fire-fire)
         - [Running without any subcommand](#running-without-any-subcommand)
         - [Subcommands](#subcommands)
       - [download subcommand](#download-subcommand)
       - [search subcommand](#search-subcommand)
+      - [grab subcommand](#grab-subcommand)
       - [downloads subcommand](#downloads-subcommand)
       - [config subcommand](#config-subcommand)
+      - [cache subcommand](#cache-subcommand)
+      - [update subcommand](#update-subcommand)
+      - [completions subcommand](#completions-subcommand)
+    - [MPV specific commands](#mpv-specific-commands)
+      - [Key Bindings](#key-bindings)
+      - [Script Messages](#script-messages)
   - [Configuration](#configuration)
   - [Contributing](#contributing)
   - [Receiving Support](#receiving-support)
@@ -55,8 +61,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, aniwatch and animepahe. The site is in the public domain and can be accessed by any one with a browser.
 
 ## Installation
 
@@ -75,12 +80,21 @@ Preferred method of installation since [Pipx](https://github.com/pypa/pipx) crea
 ```bash
 
 pipx install fastanime
+# -- or for the development version --
+pipx install 'fastanime==<latest-pre-release-tag>.dev1'
+# example
+# pipx install 'fastanime==0.60.1.dev1'
+
 ```
 
 #### Using pip
 
 ```bash
 pip install fastanime
+# -- or for the development version --
+pip install 'fastanime==<latest-pre-release-tag>.dev1'
+# example
+# pip install 'fastanime==0.60.1.dev1'
 ```
 
 ### Installing the bleeding edge version
@@ -110,7 +124,7 @@ Requirements:
 
 To build from the source, follow these steps:
 
-1. Clone the repository: `git clone https://github.com/Benex254/FastAnime.git`
+1. Clone the repository: `git clone https://github.com/Benex254/FastAnime.git --depth 1`
 2. Navigate into the folder: `cd FastAnime`
 3. Then build and Install the app:
 
@@ -143,7 +157,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]
 >
@@ -152,58 +166,100 @@ The only required external dependency, unless you won't be streaming, is [MPV](h
 > everything you could ever need with a small footprint.
 > But if you have a reason feel free to encourage as to do so.
 
-**Other dependencies that will just make your experience better:**
+**Other external dependencies that will just make your experience better:**
 
-- [fzf](https://github.com/junegunn/fzf) :fire: which is used as a better alternative to the ui.
+- [ffmpeg](https://www.ffmpeg.org/) is required to be in your path environment variables to properly download [hls](https://www.cloudflare.com/en-gb/learning/video/what-is-http-live-streaming/) streams.
+- [fzf](https://github.com/junegunn/fzf) 🔥 which is used as a better alternative to the ui.
+- [rofi](https://github.com/davatorium/rofi) 🔥 which is used as another alternative ui + the the desktop entry ui
 - [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
+- [ffmpegthumbnailer](https://github.com/dirkvdb/ffmpegthumbnailer) used for local previews of downloaded anime
+- [syncplay](https://syncplay.pl/) to enable watch together.
 
 ## Usage
 
-The app offers both a graphical interface (under development) and a robust command-line interface.
-
-> [!NOTE]
->
-> The GUI is mostly in hiatus; use the CLI for now.
-> However, you can try it out before i decided to change my objective by checking out this [release](https://github.com/Benex254/FastAnime/tree/v0.20.0).
-> But be reassured for those who aren't terminal chads, i will still complete the GUI for the fun of it
+The project offers a featureful command-line interface and MPV interface through the use of python-mpv.
+The project also offers subs in different languages thanks to aniwatch provider.
 
 ### The Commandline interface :fire:
 
-Designed for power users who prefer efficiency over browser-based streaming and still want the experience in their terminal.
+Designed for efficiency and automation. Plus has a beautiful pseudo-TUI in some of the commands.
 
-Overview of main commands:
+**Overview of main commands:**
 
 - `fastanime anilist`: Powerful command for browsing and exploring anime due to AniList integration.
 - `fastanime download`: Download anime.
 - `fastanime search`: Powerful command meant for binging since it doesn't require the interfaces
 - `fastanime downloads`: View downloaded anime and watch with MPV.
 - `fastanime config`: Quickly edit configuration settings.
+- `fastanime cache`: Quickly manage the cache fastanime uses
+- `fastanime update`: Quickly update fastanime
+- `fastanime grab`: print streams to stdout to use in non python application.
 
-Configuration is directly passed into this command at run time to override your config.
+**Overview of options**
 
-Available options include:
+Most options are directly passed into fastanime directly and are shared by multiple subcommands.
 
-- `--server;-s <server>` set the default server to auto select
-- `--continue;-c/--no-continue;-no-c` whether to continue from the last episode you were watching
-- `--quality;-q <0|1|2|3>` the link to choose from server
-- `--translation-type;- <dub|sub` what language for anime
-- `--auto-select;-a/--no-auto-select;-no-a` auto select title from provider results
-- `--auto-next;-A;/--no-auto-next;-no-A` auto select next episode
-- `-downloads-dir;-d <path>` set the folder to download anime into
+Most of the options override your config file.
+
+This is a convention to make the dev time faster since it reduces redundancy and also makes switching of subcommands with the same options easier to the end user.
+
+In general `fastanime --<option-name>`
+
+Available options for the fastanime include:
+
+- `--server <server>` or `-s <server>` set the default server to auto select
+- `--continue/--no-continue` or `-c/-no-c` whether to continue from the last episode you were watching
+- `--local-history/--remote-history` whether to use remote or local history defaults to local
+- `--quality <1080/720/480/360>` or `-q <1080/720/480/360>` the link to choose from server
+- `--translation-type <dub/sub>` or `-t <dub/sub>` what language for anime
+- `--dub` dubbed anime
+- `--sub` subbed anime
+- `--auto-select/--no-auto-select` or `-a/-no-a` auto select title from provider results
+- `--auto-next/--no-auto-next` or `-A/-no-A` auto select next episode
+- `-downloads-dir <path>` or `-d <path>` set the folder to download anime into
 - `--fzf` use fzf for the ui
 - `--default` use the default ui
 - `--preview` show a preview when using fzf
 - `--no-preview` dont show a preview when using fzf
-- `--format <yt-dlp format string>` set the format of anime downloaded and streamed based on yt-dlp format. Works when `--server gogoanime`
+- `--format <yt-dlp format string>` or `-f <yt-dlp format string>` set the format of anime downloaded and streamed based on [yt-dlp format](https://github.com/yt-dlp/yt-dlp#format-selection). Works when `--server gogoanime` or on providers that provide multi quality streams eg aniwatch
 - `--icons/--no-icons` toggle the visibility of the icons
 - `--skip/--no-skip` whether to skip the opening and ending theme songs.
 - `--rofi` use rofi for the ui
 - `--rofi-theme <path>` theme to use with rofi
 - `--rofi-theme-input <path>` theme to use with rofi input
 - `--rofi-theme-confirm <path>` theme to use with rofi confirm
+- `--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
+- `--provider <allanime/animepahe>` anime site of choice to scrape from
+- `--sync-play` or `-sp` use syncplay for streaming anime so you can watch with your friends
+- `--sub-lang <en/or any other common shortform for country>` regex is used to determine the appropriate. Only works when provider is aniwatch.
+- `--normalize-titles/--no-normalize-titles` whether to normalize provider titles
+
+Example usage of the above options
+
+```bash
+# example of syncplay intergration
+fastanime --sync-play --server sharepoint search -t <anime-title>
+
+# --- or ---
+
+# to watch with anilist intergration
+fastanime --sync-play --server sharepoint anilist
+
+# downloading dubbed anime
+fastanime --dub download <anime>
+
+# use  icons and fzf for a more elegant ui with preview
+fastanime --icons --preview --fzf anilist
+
+# use icons with default ui
+fastanime --icons --default anilist
+```
 
 #### The anilist command :fire: :fire: :fire:
 
@@ -216,6 +272,7 @@ Run `fastanime anilist` to access the main interface.
 ##### Subcommands
 
 The subcommands are mainly their as convenience. Since all the features already exist in the main interface.
+Most of the subcommands share the common option `--dump-json` or `-d` which will print only the json data and suppress the ui.
 
 - `fastanime anilist trending`: Top 15 trending anime.
 - `fastanime anilist recent`: Top 15 recently updated anime.
@@ -225,6 +282,46 @@ The subcommands are mainly their as convenience. Since all the features already
 - `fastanime anilist favourites`: Top 15 favorite anime.
 - `fastanime anilist random`: get random anime
 
+**FastAnime Anilist Search subcommand** 🔥 🔥 🔥
+
+It is by far one of the most powerful commands.
+It offers the following options:
+
+- `--sort <MediaSort>` or `-s <MediaSort>`
+- `--title <anime-title>` or `-t <anime-title>`
+- `--tags <tag>` or `-T <tag>` can be specified multiple times for different tags to filter by.
+- `--year <year>` or `-y <year>`
+- `--status <MediaStatus>` or `-S <MediaStatus>`
+- `--media-format <MediaFormat>` or `-f <MediaFormat>`
+- `--season <MediaSeason>`
+- `--genres <genre>` or `-g <genre>` can be specified multiple times.
+
+Example:
+
+```bash
+# get anime with the tag of isekai
+fastanime anilist search -T isekai
+
+# get anime of 2024 and sort by popularity
+fastanime anilist search -y 2024 -s POPULARITY_DESC
+
+# get anime of 2024 season WINTER
+fastanime anilist search -y 2024 --season WINTER
+
+# get anime genre action and tag isekai,magic
+ fastanime anilist search -g Action -T Isekai -T Magic
+
+# get anime of 2024 thats finished airing
+fastanime anilist search -y 2024 -S FINISHED
+
+# get the most favourite anime movies
+fastanime anilist search -f MOVIE -s FAVOURITES_DESC
+```
+
+For more details visit the anilist docs or just get the completions which will improve the experience.
+
+Like seriously **[get the completions](https://github.com/Benex254/FastAnime#completions-subcommand)** and the experience will be a 💯 💯 better.
+
 The following are commands you can only run if you are signed in to your AniList account:
 
 - `fastanime anilist watching`
@@ -234,7 +331,7 @@ The following are commands you can only run if you are signed in to your AniList
 - `fastanime anilist paused`
 - `fastanime anilist completed`
 
-Plus: `fastanime anilist notifier` :fire:
+Plus: `fastanime anilist notifier` 🔥
 
 ```bash
 # basic form
@@ -247,7 +344,7 @@ fastanime --log anilist notifier
 fastanime --log-file anilist notifier
 ```
 
-The above commands will start a loop that checks every 2 minutes if any of the anime in your watch list that are aireing has just released a new episode.
+The above commands will start a loop that checks every 2 minutes if any of the anime in your watch list that are airing has just released a new episode.
 
 The notification will consist of a cover image of the anime in none windows systems.
 
@@ -265,12 +362,15 @@ end
 > [!NOTE]
 > To sign in just run `fastanime anilist login` and follow the instructions.
 > To view your login status `fastanime anilist login --status`
+> To erase login data `fastanime anilist login --erase`
 
 #### download subcommand
 
 Download anime to watch later dub or sub with this one command.
-Its optimized for scripting due to fuzzy matching.
+Its optimized for scripting due to fuzzy matching; basically you don't have to manually select search results.
+
 So every step of the way has been and can be automated.
+Uses a list slicing syntax similar to that of python as the value for the `-r` option.
 
 > [!NOTE]
 >
@@ -281,29 +381,132 @@ So every step of the way has been and can be automated.
 
 ```bash
 # Download all available episodes
-fastanime download <anime-title>
+# multiple titles can be specified with -t option
+fastanime download -t <anime-title> -t <anime-title>
+# -- or --
+fastanime download -t <anime-title> -t <anime-title> -r ':'
+
+# download latest episode for the two anime titles
+# the number can be any no of latest episodes but a minus sign
+# must be present
+fastanime download -t <anime-title> -t <anime-title> -r '-1'
+
+# latest 5
+fastanime download -t <anime-title> -t <anime-title> -r '-5'
 
 # Download specific episode range
 # be sure to observe the range Syntax
-fastanime download <anime-title> -r <episodes-start>-<episodes-end>
+fastanime download -t <anime-title> -r '<episodes-start>:<episodes-end>:<step>'
+
+fastanime download -t <anime-title> -r '<episodes-start>:<episodes-end>'
+
+fastanime download -t <anime-title> -r '<episodes-start>:'
+
+fastanime download -t <anime-title> -r ':<episodes-end>'
+
+# download specific episode
+# remember python indexing starts at 0
+fastanime download -t <anime-title> -r '<episode-1>:<episode>'
+
+# merge subtitles with ffmpeg to mkv format; aniwatch tends to give subs as separate files
+# and dont prompt for anything
+# eg existing file in destination instead remove
+# and clean
+# ie remove original files (sub file and vid file)
+# only keep merged files
+fastanime download -t <anime-title> --merge --clean --no-prompt
+
+# EOF is used since -t always expects a title
+# you can supply anime titles from file or -t at the same time
+#
+# from stdin
+echo -e "<anime-title>\n<anime-title>\n<anime-title>" | fastanime download -t "EOF" -r <range> -f -
+
+# from file
+fastanime download -t "EOF" -r <range> -f <file-path>
+
+
 ```
 
 #### search subcommand
 
 Powerful command mainly aimed at binging anime. Since it doesn't require interaction with the interfaces.
 
+Uses a list slicing syntax similar to that of python as the value of the `-r` option.
+
 **Syntax:**
 
 ```bash
-# basic form where you will still be promted for the episode number
-fastanime search <anime-title>
+# basic form where you will still be prompted for the episode number
+# multiple titles can be specified with the -t option
+fastanime search -t <anime-title> -t <anime-title>
 
 # binge all episodes with this command
-fastanime search <anime-title> -
+fastanime search -t <anime-title> -r ':'
+
+# watch latest episode
+fastanime search -t <anime-title> -r '-1'
 
 # binge a specific episode range with this command
 # be sure to observe the range Syntax
-fastanime search <anime-title> <episodes-start>-<episodes-end>
+fastanime search -t <anime-title> -r '<start>:<stop>'
+
+fastanime search -t <anime-title> -r '<start>:<stop>:<step>'
+
+fastanime search -t <anime-title> -r '<start>:'
+
+fastanime search -t <anime-title> -r ':<end>'
+```
+
+#### grab subcommand
+
+Helper command to print streams to stdout so it can be used by non-python applications.
+
+The format of the printed out data is json and can be either an array or object depending on how many anime titles have been specified in the command-line or through a subprocess.
+
+> [!TIP]
+> For python applications just use its python api, for even greater and easier control.
+> So just add fastanime as one of your dependencies.
+
+Uses a list slicing syntax similar to that of python as the value of the `-r` option.
+
+**Syntax:**
+
+```bash
+# --- print anime info + episode streams ---
+
+# multiple titles can be specified with the -t option
+fastanime grab -t <anime-title> -t <anime-title>
+
+# -- or --
+
+# print all available episodes
+fastanime grab -t <anime-title> -r ':'
+
+# print the latest episode
+fastanime grab -t <anime-title> -r '-1'
+
+# print a specific episode range
+# be sure to observe the range Syntax
+fastanime grab -t <anime-title> -r '<start>:<stop>'
+
+fastanime grab -t <anime-title> -r '<start>:<stop>:<step>'
+
+fastanime grab -t <anime-title> -r '<start>:'
+
+fastanime grab -t <anime-title> -r ':<end>'
+
+# --- grab options ---
+
+# print search results only
+fastanime grab -t <anime-title> -r <range> --search-results-only
+
+# print anime info only
+fastanime grab -t <anime-title> -r <range> --anime-info-only
+
+# print episode streams only
+fastanime grab -t <anime-title> -r <range> --episode-streams-only
+
 ```
 
 #### downloads subcommand
@@ -315,9 +518,21 @@ View and stream the anime you downloaded using MPV.
 ```bash
 fastanime downloads
 
+# view individual episodes
+fastanime downloads --view-episodes
+# --- or ---
+fastanime downloads -v
+
+# to set seek time when using ffmpegthumbnailer for local previews
+# -1 means random and is the default
+fastanime downloads --time-to-seek <intRange(-1,100)>
+# --- or ---
+fastanime downloads -t <intRange(-1,100)>
+
 # to get the path to the downloads folder set
 fastanime downloads --path
 # useful when you want to use the value for other programs
+
 ```
 
 #### config subcommand
@@ -331,32 +546,143 @@ fastanime config
 
 # to get config path which is useful if you want to use it for another program.
 fastanime config --path
+
+# add a desktop entry
+fastanime config --desktop-entry
+
+# view current contents of your configuration or can be used to get an example config
+fastanime config --view
 ```
 
 > [!Note]
 >
-> If it opens [vim](https://www.vim.org/download.php) you can exit by typing `:q` in case you don't know.
+> If it opens [vim](https://www.vim.org/download.php) you can exit by typing `:q` .
+
+#### cache subcommand
+
+Easily manage the data fastanime has cached; for the previews.
+
+**Syntax:**
+
+```bash
+# delete everything in the cache dir
+fastanime cache --clean
+
+# print the path to the cache dir and exit
+fastanime cache --path
+
+# print the current size of the cache dir and exit
+fastanime cache --size
+
+# open the cache dir and exit
+fastanime cache
+```
+
+#### update subcommand
+
+Easily update fastanime to latest
+
+**Syntax:**
+
+```bash
+# update fastanime to latest
+fastanime update
+
+# check for latest release
+fastanime update --check
+```
+
+#### 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.
+This is all powered with [python-mpv]() which enables writing mpv scripts with python just like how it would be done in lua.
+
+#### Key Bindings
+
+`<shift>+n` fetch the next episode
+
+`<shift>+p` fetch the previous episode
+
+`<shift>+t` toggle the translation type from dub to sub
+
+`<shift>+a` toggle auto next episode
+
+`<shit>+r` reload episode
+
+#### Script Messages
+
+Commands issued in the MPV console.
+
+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>
+
+# to select quality
+script-message select-quality <1080/720/480/360>
+```
+
+## styling the default interface
+
+The default interface uses inquirerPy which is customizable. Read here to findout more <https://inquirerpy.readthedocs.io/en/latest/pages/env.html>
 
 ## Configuration
 
-The app includes sensible defaults but can be customized extensively. Configuration is stored in `.ini` format at `~/.config/FastAnime/config.ini` on Linux and mac or somewhere on windows; you can check by running `fastanime config --path`.
+The app includes sensible defaults but can be customized extensively. Configuration is stored in `.ini` format at `~/.config/FastAnime/config.ini` on arch linux; for the other operating systems you can check by running `fastanime config --path`.
 
 ```ini
 [stream]
 continue_from_history = True  # Auto continue from watch history
+
+# which history to use [local/remote]
+preferred_history = local
+
+# force mpv window
+# passed directly to mpv so values are same
+force_window = immediate
+
 translation_type = sub  # Preferred language for anime (options: dub, sub)
+
 server = top  # Default server (options: dropbox, sharepoint, wetransfer.gogoanime, top, wixmp)
+
 auto_next = False  # Auto-select next episode
+
 # Auto select the anime provider results with fuzzy find.
 # Note this wont always be correct.But 99% of the time will be.
 auto_select=True
+
 # whether to skip the opening and ending theme songs
 # note requires ani-skip to be in path
 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
 
+# whether to use python mpv for enhanced experience
+use_mpv_mod=False
+
 # the format of downloaded anime and trailer
 # based on yt-dlp format and passed directly to it
 # learn more by looking it up on their site
@@ -366,15 +692,25 @@ error=3
 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)
+
+normalize_titles = true
+
 downloads_dir = <Default-videos-dir>/FastAnime  # Download directory
+
 preview=false # whether to show a preview window when using fzf or rofi
 
 use_fzf=False # whether to use fzf as the interface for the anilist command and others.
 
 use_rofi=false # whether to use rofi for the ui
+
 rofi_theme=<path-to-rofi-theme-file>
+
 rofi_theme_input=<path-to-rofi-theme-file>
+
 rofi_theme_confirm=<path-to-rofi-theme-file>
 
 
@@ -393,11 +729,11 @@ notification_duration=2
 
 We welcome your issues and feature requests. However, due to time constraints, we currently do not plan to add another provider.
 
-If you wish to contribute directly, please first open an issue describing your proposed changes so it can be discussed.
+If you wish to contribute directly, please first open an issue describing your proposed changes so it can be discussed or if you are in a rush for the feature to be merged just open a pr.
 
 ## Receiving Support
 
-For inquiries, join our [Discord Server](https://discord.gg/4NUTj5Pt).
+For inquiries, join our [Discord Server](https://discord.gg/C4rhMA4mmK).
 
 <p align="center">
 <a href="https://discord.gg/C4rhMA4mmK">
@@ -405,7 +741,6 @@ For inquiries, join our [Discord Server](https://discord.gg/4NUTj5Pt).
 </a>
 </p>
 
-
 ## Supporting the Project
 
 Show your support by starring our GitHub repository or [buying us a coffee](https://ko-fi.com/benex254).

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

fastanime/Utility/__init__.py

@@ -0,0 +1,4 @@
+"""This package exist as away to expose functions and classes that my be useful to a developer using the fastanime library
+
+[TODO:description]
+"""

fastanime/Utility/anilist_data_helper.py

@@ -1,13 +1,12 @@
 from datetime import datetime
+from typing import TYPE_CHECKING
 
-from ..libs.anilist.anilist_data_schema import (
-    AnilistDateObject,
-    AnilistMediaNextAiringEpisode,
-)
+if TYPE_CHECKING:
+    from ..libs.anilist.types import AnilistDateObject, AnilistMediaNextAiringEpisode
 
 
 # TODO: Add formating options for the final date
-def format_anilist_date_object(anilist_date_object: AnilistDateObject):
+def format_anilist_date_object(anilist_date_object: "AnilistDateObject"):
     if anilist_date_object:
         return f"{anilist_date_object['day']}/{anilist_date_object['month']}/{anilist_date_object['year']}"
     else:
@@ -28,7 +27,7 @@ def format_list_data_with_comma(data: list | None):
         return "None"
 
 
-def extract_next_airing_episode(airing_episode: AnilistMediaNextAiringEpisode):
+def extract_next_airing_episode(airing_episode: "AnilistMediaNextAiringEpisode"):
     if airing_episode:
         return f"{airing_episode['episode']} on {format_anilist_timestamp(airing_episode['airingAt'])}"
     else:

fastanime/Utility/data.py

@@ -9,6 +9,3 @@ anime_normalizer = {
     "Dungeon ni Deai o Motomeru no wa Machigatte Iru Darouka": "Dungeon ni Deai wo Motomeru no wa Machigatteiru Darou ka",
     'Hazurewaku no "Joutai Ijou Skill" de Saikyou ni Natta Ore ga Subete wo Juurin suru made': "Hazure Waku no [Joutai Ijou Skill] de Saikyou ni Natta Ore ga Subete wo Juurin Suru made",
 }
-
-
-anilist_sort_normalizer = {"search match": "SEARCH_MATCH"}

fastanime/Utility/downloader/downloader.py

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

fastanime/Utility/user_data_helper.py

@@ -1,40 +0,0 @@
-import json
-import logging
-import os
-
-from ..constants import USER_DATA_PATH
-
-logger = logging.getLogger(__name__)
-
-
-# TODO: merger this functionality with the config object
-class UserData:
-    user_data = {"watch_history": {}, "animelist": [], "user": {}}
-
-    def __init__(self):
-        try:
-            if os.path.isfile(USER_DATA_PATH):
-                with open(USER_DATA_PATH, "r") as f:
-                    user_data = json.load(f)
-                    self.user_data.update(user_data)
-        except Exception as e:
-            logger.error(e)
-
-    def update_watch_history(self, watch_history: dict):
-        self.user_data["watch_history"] = watch_history
-        self._update_user_data()
-
-    def update_user_info(self, user: dict):
-        self.user_data["user"] = user
-        self._update_user_data()
-
-    def update_animelist(self, anime_list: list):
-        self.user_data["animelist"] = list(set(anime_list))
-        self._update_user_data()
-
-    def _update_user_data(self):
-        with open(USER_DATA_PATH, "w") as f:
-            json.dump(self.user_data, f)
-
-
-user_data_helper = UserData()

fastanime/Utility/utils.py

@@ -1,79 +1,25 @@
 import logging
-import os
-import re
-from functools import lru_cache
+from typing import TYPE_CHECKING
 
 from thefuzz import fuzz
 
-from fastanime.libs.anilist.anilist_data_schema import AnilistBaseMediaDataSchema
-
 from .data import anime_normalizer
 
+if TYPE_CHECKING:
+    from ..libs.anilist.types import AnilistBaseMediaDataSchema
+
 logger = logging.getLogger(__name__)
 
 
-@lru_cache()
-def remove_html_tags(text: str):
-    clean = re.compile("<.*?>")
-    return re.sub(clean, "", text)
+def sort_by_episode_number(filename: str):
+    import re
 
-
-@lru_cache()
-def sanitize_filename(filename: str):
-    """
-    Sanitize a string to be safe for use as a file name.
-
-    :param filename: The original filename string.
-    :return: A sanitized filename string.
-    """
-    # List of characters not allowed in filenames on various operating systems
-    invalid_chars = r'[<>:"/\\|?*\0]'
-    reserved_names = {
-        "CON",
-        "PRN",
-        "AUX",
-        "NUL",
-        "COM1",
-        "COM2",
-        "COM3",
-        "COM4",
-        "COM5",
-        "COM6",
-        "COM7",
-        "COM8",
-        "COM9",
-        "LPT1",
-        "LPT2",
-        "LPT3",
-        "LPT4",
-        "LPT5",
-        "LPT6",
-        "LPT7",
-        "LPT8",
-        "LPT9",
-    }
-
-    # Replace invalid characters with an underscore
-    sanitized = re.sub(invalid_chars, " ", filename)
-
-    # Remove leading and trailing whitespace
-    sanitized = sanitized.strip()
-
-    # Check for reserved filenames
-    name, ext = os.path.splitext(sanitized)
-    if name.upper() in reserved_names:
-        name += "_file"
-        sanitized = name + ext
-
-    # Ensure the filename is not empty
-    if not sanitized:
-        sanitized = "default_filename"
-
-    return sanitized
+    match = re.search(r"\d+", filename)
+    return int(match.group()) if match else 0
 
 
 def anime_title_percentage_match(
-    possible_user_requested_anime_title: str, anime: AnilistBaseMediaDataSchema
+    possible_user_requested_anime_title: str, anime: "AnilistBaseMediaDataSchema"
 ) -> float:
     """Returns the percentage match between the possible title and user title
 
@@ -97,10 +43,3 @@ def anime_title_percentage_match(
     )
     logger.info(f"{locals()}")
     return percentage_ratio
-
-
-if __name__ == "__main__":
-    # Example usage
-    unsafe_filename = "CON:example?file*name.txt"
-    safe_filename = sanitize_filename(unsafe_filename)
-    print(safe_filename)  # Output: 'CON_example_file_name.txt'

fastanime/__init__.py

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

fastanime/cli/__init__.py

@@ -3,9 +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 ..Utility.data import anilist_sort_normalizer
+from ..libs.anime_provider import SERVERS_AVAILABLE, anime_sources
 from .commands import LazyGroup
 
 commands = {
@@ -15,6 +13,9 @@ commands = {
     "config": "config.config",
     "downloads": "downloads.downloads",
     "cache": "cache.cache",
+    "completions": "completions.completions",
+    "update": "update.update",
+    "grab": "grab.grab",
 }
 
 
@@ -42,7 +43,6 @@ signal.signal(signal.SIGINT, handle_exit)
 @click.option("--log", help="Allow logging to stdout", is_flag=True)
 @click.option("--log-file", help="Allow logging to a file", is_flag=True)
 @click.option("--rich-traceback", help="Use rich to output tracebacks", is_flag=True)
-@click.option("--update", help="Update fastanime to the latest version", is_flag=True)
 @click.option(
     "-p",
     "--provider",
@@ -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(
@@ -68,6 +68,11 @@ signal.signal(signal.SIGINT, handle_exit)
     type=bool,
     help="Continue from last episode?",
 )
+@click.option(
+    "--local-history/--remote-history",
+    type=bool,
+    help="Whether to continue from local history or remote history",
+)
 @click.option(
     "--skip/--no-skip",
     type=bool,
@@ -76,7 +81,14 @@ signal.signal(signal.SIGINT, handle_exit)
 @click.option(
     "-q",
     "--quality",
-    type=click.IntRange(0, 3),
+    type=click.Choice(
+        [
+            "360",
+            "480",
+            "720",
+            "1080",
+        ]
+    ),
     help="set the quality of the stream",
 )
 @click.option(
@@ -85,6 +97,11 @@ signal.signal(signal.SIGINT, handle_exit)
     type=click.Choice(["dub", "sub"]),
     help="Anime language[dub/sub]",
 )
+@click.option(
+    "-sl",
+    "--sub-lang",
+    help="Set the preferred language for subs",
+)
 @click.option(
     "-A/-no-A",
     "--auto-next/--no-auto-next",
@@ -98,9 +115,9 @@ signal.signal(signal.SIGINT, handle_exit)
     help="Auto select anime title?",
 )
 @click.option(
-    "-S",
-    "--sort-by",
-    type=click.Choice(anilist_sort_normalizer.keys()),  # pyright: ignore
+    "--normalize-titles/--no-normalize-titles",
+    type=bool,
+    help="whether to normalize anime and episode titls given by providers",
 )
 @click.option("-d", "--downloads-dir", type=click.Path(), help="Downloads location")
 @click.option("--fzf", is_flag=True, help="Use fzf for the ui")
@@ -126,23 +143,28 @@ 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.option("--sync-play", "-sp", help="Use sync play", is_flag=True)
 @click.pass_context
 def run_cli(
     ctx: click.Context,
     log,
     log_file,
     rich_traceback,
-    update,
     provider,
     server,
     format,
     continue_,
+    local_history,
     skip,
     translation_type,
+    sub_lang,
     quality,
     auto_next,
     auto_select,
-    sort_by,
+    normalize_titles,
     downloads_dir,
     fzf,
     default,
@@ -155,6 +177,8 @@ def run_cli(
     rofi_theme,
     rofi_theme_confirm,
     rofi_theme_input,
+    use_mpv_mod,
+    sync_play,
 ):
     from .config import Config
 
@@ -167,44 +191,51 @@ def run_cli(
         FORMAT = "%(message)s"
 
         logging.basicConfig(
-            level="NOTSET", format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
+            level=logging.DEBUG, format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
         )
         logger = logging.getLogger(__name__)
         logger.info("logging has been initialized")
     elif log_file:
         import logging
 
-        from ..constants import NOTIFIER_LOG_FILE_PATH
+        from ..constants import LOG_FILE_PATH
 
         format = "%(asctime)s%(levelname)s: %(message)s"
         logging.basicConfig(
             level=logging.DEBUG,
-            filename=NOTIFIER_LOG_FILE_PATH,
+            filename=LOG_FILE_PATH,
             format=format,
             datefmt="[%d/%m/%Y@%H:%M:%S]",
             filemode="w",
         )
+    else:
+        import logging
+
+        logging.basicConfig(level=logging.CRITICAL)
     if rich_traceback:
         from rich.traceback import install
 
         install()
-    if update and None:
-        from .app_updater import update_app
-
-        update_app()
-        return
 
+    if sync_play:
+        ctx.obj.sync_play = sync_play
     if provider:
         ctx.obj.provider = provider
-        ctx.obj.load_config()
     if server:
         ctx.obj.server = server
     if format:
         ctx.obj.format = format
+    if sub_lang:
+        ctx.obj.sub_lang = sub_lang
     if ctx.get_parameter_source("continue_") == click.core.ParameterSource.COMMANDLINE:
         ctx.obj.continue_from_history = continue_
     if ctx.get_parameter_source("skip") == click.core.ParameterSource.COMMANDLINE:
         ctx.obj.skip = skip
+    if (
+        ctx.get_parameter_source("normalize_titles")
+        == click.core.ParameterSource.COMMANDLINE
+    ):
+        ctx.obj.normalize_titles = normalize_titles
 
     if quality:
         ctx.obj.quality = quality
@@ -212,13 +243,21 @@ def run_cli(
         ctx.obj.auto_next = auto_next
     if ctx.get_parameter_source("icons") == click.core.ParameterSource.COMMANDLINE:
         ctx.obj.icons = icons
+    if (
+        ctx.get_parameter_source("local_history")
+        == click.core.ParameterSource.COMMANDLINE
+    ):
+        ctx.obj.preferred_history = "local" if local_history else "remote"
     if (
         ctx.get_parameter_source("auto_select")
         == click.core.ParameterSource.COMMANDLINE
     ):
         ctx.obj.auto_select = auto_select
-    if sort_by:
-        ctx.obj.sort_by = sort_by
+    if (
+        ctx.get_parameter_source("use_mpv_mod")
+        == click.core.ParameterSource.COMMANDLINE
+    ):
+        ctx.obj.use_mpv_mod = use_mpv_mod
     if downloads_dir:
         ctx.obj.downloads_dir = downloads_dir
     if translation_type:

fastanime/cli/app_updater.py

@@ -2,8 +2,8 @@ import pathlib
 import re
 import shlex
 import shutil
+import subprocess
 import sys
-from subprocess import PIPE, Popen
 
 import requests
 from rich import print
@@ -26,7 +26,24 @@ def check_for_updates():
 
     if request.status_code == 200:
         release_json = request.json()
-        return (release_json["tag_name"] == __version__, release_json)
+        remote_tag = list(
+            map(int, release_json["tag_name"].replace("v", "").split("."))
+        )
+        local_tag = list(map(int, __version__.replace("v", "").split(".")))
+        if (
+            (remote_tag[0] > local_tag[0])
+            or (remote_tag[1] > local_tag[1] and remote_tag[0] == local_tag[0])
+            or (
+                remote_tag[2] > local_tag[2]
+                and remote_tag[0] == local_tag[0]
+                and remote_tag[1] == local_tag[1]
+            )
+        ):
+            is_latest = False
+        else:
+            is_latest = True
+
+        return (is_latest, release_json)
     else:
         print(request.text)
         return (False, {})
@@ -34,71 +51,72 @@ def check_for_updates():
 
 def is_git_repo(author, repository):
     # Check if the current directory contains a .git folder
-    if not pathlib.Path("./.git").exists():
+    git_dir = pathlib.Path(".git")
+    if not git_dir.exists() or not git_dir.is_dir():
         return False
 
-    repository_qualname = f"{author}/{repository}"
-
-    # Read the .git/config file to find the remote repository URL
-    config_path = pathlib.Path("./.git/config")
+    # Check if the config file exists
+    config_path = git_dir / "config"
     if not config_path.exists():
         return False
-    print("here")
 
-    with open(config_path, "r") as git_config:
-        git_config_content = git_config.read()
-
-    # Use regex to find the repository URL in the config file
-    repo_name_pattern = r"\[remote \"origin\"\]\s+url = .*\/([^/]+\/[^/]+)\.git"
-    match = re.search(repo_name_pattern, git_config_content)
-    print(match)
-
-    if match is None:
+    try:
+        # Read the .git/config file to find the remote repository URL
+        with config_path.open("r") as git_config:
+            git_config_content = git_config.read()
+    except (FileNotFoundError, PermissionError):
         return False
 
-    # Extract the repository name and compare with the expected repository_qualname
-    config_repo_name = match.group(1)
-    return config_repo_name == repository_qualname
+    # Use regex to find the repository URL in the config file
+    repo_name_pattern = r"url\s*=\s*.+/([^/]+/[^/]+)\.git"
+    match = re.search(repo_name_pattern, git_config_content)
+
+    # Return True if match found and repository name matches
+    return bool(match) and match.group(1) == f"{author}/{repository}"
 
 
 def update_app():
     is_latest, release_json = check_for_updates()
     if is_latest:
         print("[green]App is up to date[/]")
-        return
+        return False, release_json
     tag_name = release_json["tag_name"]
 
     print("[cyan]Updating app to version %s[/]" % tag_name)
     if is_git_repo(AUTHOR, APP_NAME):
-        executable = shutil.which("git")
+        GIT_EXECUTABLE = shutil.which("git")
         args = [
-            executable,
+            GIT_EXECUTABLE,
             "pull",
         ]
 
         print(f"Pulling latest changes from the repository via git: {shlex.join(args)}")
 
-        if not executable:
-            return print("[red]Cannot find git.[/]")
+        if not GIT_EXECUTABLE:
+            print("[red]Cannot find git please install it.[/]")
+            return False, release_json
 
-        process = Popen(
+        process = subprocess.run(
             args,
-            stdout=PIPE,
-            stderr=PIPE,
         )
 
-        process.communicate()
     else:
-        executable = sys.executable
+        if PIPX_EXECUTABLE := shutil.which("pipx"):
+            process = subprocess.run([PIPX_EXECUTABLE, "upgrade", APP_NAME])
+        else:
+            PYTHON_EXECUTABLE = sys.executable
 
-        args = [
-            executable,
-            "-m",
-            "pip",
-            "install",
-            APP_NAME,
-            "--user",
-            "--no-warn-script-location",
-        ]
-        process = Popen(args)
-        process.communicate()
+            args = [
+                PYTHON_EXECUTABLE,
+                "-m",
+                "pip",
+                "install",
+                APP_NAME,
+                "--user",
+                "--no-warn-script-location",
+            ]
+            process = subprocess.run(args)
+    if process.returncode == 0:
+        return True, release_json
+    else:
+        return False, release_json

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

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

fastanime/cli/commands/anilist/dropped.py

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

fastanime/cli/commands/anilist/favourites.py

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

fastanime/cli/commands/anilist/login.py

@@ -8,41 +8,54 @@ if TYPE_CHECKING:
 
 @click.command(help="Login to your anilist account")
 @click.option("--status", "-s", help="Whether you are logged in or not", is_flag=True)
+@click.option("--erase", "-e", help="Erase your login details", is_flag=True)
 @click.pass_obj
-def login(config: "Config", status):
-    from click import launch
+def login(config: "Config", status, erase):
+    from sys import exit
+
     from rich import print
     from rich.prompt import Confirm, Prompt
 
-    from ....anilist import AniList
-    from ...utils.tools import exit_app
-
     if status:
         is_logged_in = True if config.user else False
         message = (
-            "You are logged in :happy:" if is_logged_in else "You arent logged in :cry"
+            "You are logged in :smile:" if is_logged_in else "You arent logged in :cry:"
         )
         print(message)
         print(config.user)
-        exit_app()
-    if config.user:
-        print("Already logged in :confused:")
-        if not Confirm.ask("or would you like to reloggin", default=True):
-            exit_app()
-    # ---- new loggin -----
-    print(
-        f"A browser session will be opened ( [link]{config.fastanime_anilist_app_login_url}[/link] )",
-    )
-    launch(config.fastanime_anilist_app_login_url, wait=True)
-    print("Please paste the token provided here")
-    token = Prompt.ask("Enter token")
-    user = AniList.login_user(token)
-    if not user:
-        print("Sth went wrong", user)
-        exit_app()
-        return
-    user["token"] = token
-    config.update_user(user)
-    print("Successfully saved credentials")
-    print(user)
-    exit_app()
+        exit(0)
+    elif erase:
+        if Confirm.ask(
+            "Are you sure you want to erase your login status", default=False
+        ):
+            config.update_user({})
+            print("Success")
+            exit(0)
+        else:
+            exit(1)
+    else:
+        from click import launch
+
+        from ....anilist import AniList
+
+        if config.user:
+            print("Already logged in :confused:")
+            if not Confirm.ask("or would you like to reloggin", default=True):
+                exit(0)
+        # ---- new loggin -----
+        print(
+            f"A browser session will be opened ( [link]{config.fastanime_anilist_app_login_url}[/link] )",
+        )
+        launch(config.fastanime_anilist_app_login_url, wait=True)
+        print("Please paste the token provided here")
+        token = Prompt.ask("Enter token")
+        user = AniList.login_user(token)
+        if not user:
+            print("Sth went wrong", user)
+            exit(1)
+            return
+        user["token"] = token
+        config.update_user(user)
+        print("Successfully saved credentials")
+        print(user)
+        exit(0)

fastanime/cli/commands/anilist/notifier.py

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

fastanime/cli/commands/anilist/paused.py

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

fastanime/cli/commands/anilist/planning.py

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

fastanime/cli/commands/anilist/popular.py

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

fastanime/cli/commands/anilist/random_anime.py

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

fastanime/cli/commands/anilist/recent.py

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

fastanime/cli/commands/anilist/rewatching.py

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

fastanime/cli/commands/anilist/scores.py

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

fastanime/cli/commands/anilist/search.py

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

fastanime/cli/commands/anilist/trending.py

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

fastanime/cli/commands/anilist/upcoming.py

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

fastanime/cli/commands/anilist/watching.py

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

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, help="print fish completions")
+@click.option("--zsh", is_flag=True, help="print zsh completions")
+@click.option("--bash", is_flag=True, help="print bash completions")
+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/config.py

@@ -1,47 +1,92 @@
+from typing import TYPE_CHECKING
+
 import click
 
+if TYPE_CHECKING:
+    from ..config import Config
+
 
 @click.command(
     help="Opens up your fastanime config in your preferred editor",
     short_help="Edit your config",
 )
 @click.option("--path", "-p", help="Print the config location and exit", is_flag=True)
+@click.option(
+    "--view", "-v", help="View the current contents of your config", is_flag=True
+)
 @click.option(
     "--desktop-entry",
     "-d",
     help="Configure the desktop entry of fastanime",
     is_flag=True,
 )
-# @click.pass_obj
-def config(path, desktop_entry):
-    pass
+@click.pass_obj
+def config(config: "Config", path, view, desktop_entry):
+    import sys
 
-    from pyshortcuts import make_shortcut
     from rich import print
 
-    from ...constants import APP_NAME, ICON_PATH, USER_CONFIG_PATH
+    from ... import __version__
+    from ...constants import APP_NAME, ICON_PATH, S_PLATFORM, USER_CONFIG_PATH
 
     if path:
         print(USER_CONFIG_PATH)
+    elif view:
+        print(config)
     elif desktop_entry:
+        import os
         import shutil
+        from pathlib import Path
+        from textwrap import dedent
+
+        from rich import print
+        from rich.prompt import Confirm
+
+        from ..utils.tools import exit_app
 
         FASTANIME_EXECUTABLE = shutil.which("fastanime")
         if FASTANIME_EXECUTABLE:
             cmds = f"{FASTANIME_EXECUTABLE} --rofi anilist"
         else:
-            cmds = "_ -m fastanime --rofi anilist"
-        shortcut = make_shortcut(
-            name=APP_NAME,
-            description="Watch Anime from the terminal",
-            icon=ICON_PATH,
-            script=cmds,
-            terminal=False,
-        )
-        if shortcut:
-            print("Success", shortcut)
+            cmds = f"{sys.executable} -m fastanime --rofi anilist"
+
+        # TODO: Get funs of the other platforms to complete this lol
+        if S_PLATFORM == "win32":
+            print(
+                "Not implemented; the author thinks its not straight forward so welcomes lovers of windows to try and implement it themselves or to switch to a proper os like arch linux or pray the author gets bored 😜"
+            )
+        elif S_PLATFORM == "darwin":
+            print(
+                "Not implemented; the author thinks its not straight forward so welcomes lovers of mac to try and implement it themselves  or to switch to a proper os like arch linux or pray the author gets bored 😜"
+            )
         else:
-            print("Failed")
+            desktop_entry = dedent(
+                f"""
+                [Desktop Entry]
+                Name={APP_NAME}
+                Type=Application
+                version={__version__}
+                Path={Path().home()}
+                Comment=Watch anime from your terminal 
+                Terminal=false
+                Icon={ICON_PATH}
+                Exec={cmds}
+                Categories=Entertainment
+            """
+            )
+            base = os.path.expanduser("~/.local/share/applications")
+            desktop_entry_path = os.path.join(base, f"{APP_NAME}.desktop")
+            if os.path.exists(desktop_entry_path):
+                if not Confirm.ask(
+                    f"The file already exists {desktop_entry_path}; or would you like to rewrite it",
+                    default=False,
+                ):
+                    exit_app(1)
+            with open(desktop_entry_path, "w") as f:
+                f.write(desktop_entry)
+            with open(desktop_entry_path) as f:
+                print(f"Successfully wrote \n{f.read()}")
+                exit_app(0)
     else:
         import click
 

fastanime/cli/commands/download.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING
 
 import click
 
+from ..completion_functions import anime_titles_shell_complete
+
 if TYPE_CHECKING:
     from ..config import Config
 
@@ -10,24 +12,77 @@ if TYPE_CHECKING:
     help="Download anime using the anime provider for a specified range",
     short_help="Download anime",
 )
-@click.argument(
-    "anime-title",
+@click.option(
+    "--anime-titles",
+    "--anime_title",
+    "-t",
     required=True,
+    shell_complete=anime_titles_shell_complete,
+    multiple=True,
+    help="Specify which anime to download",
 )
 @click.option(
     "--episode-range",
     "-r",
-    help="A range of episodes to download",
+    help="A range of episodes to download (start-end)",
 )
 @click.option(
-    "--highest_priority",
-    "-h",
-    help="Choose stream indicated as highest priority",
+    "--file",
+    "-f",
+    type=click.File(),
+    help="A file to read from all anime to download",
+)
+@click.option(
+    "--force-unknown-ext",
+    "-F",
+    help="This option forces yt-dlp to download extensions its not aware of",
     is_flag=True,
 )
+@click.option(
+    "--silent/--no-silent",
+    "-q/-V",
+    type=bool,
+    help="Download silently (during download)",
+    default=True,
+)
+@click.option("--verbose", "-v", is_flag=True, help="Download verbosely (everywhere)")
+@click.option(
+    "--merge", "-m", is_flag=True, help="Merge the subfile with video using ffmpeg"
+)
+@click.option(
+    "--clean",
+    "-c",
+    is_flag=True,
+    help="After merging delete the original files",
+)
+@click.option(
+    "--wait-time",
+    "-w",
+    type=int,
+    help="The amount of time to wait after downloading is complete before the screen is completely cleared",
+    default=60,
+)
+@click.option(
+    "--prompt/--no-prompt",
+    help="Whether to prompt for anything instead just do the best thing",
+    default=True,
+)
 @click.pass_obj
-def download(config: "Config", anime_title, episode_range, highest_priority):
-    from click import clear
+def download(
+    config: "Config",
+    anime_titles: tuple,
+    episode_range,
+    file,
+    force_unknown_ext,
+    silent,
+    verbose,
+    merge,
+    clean,
+    wait_time,
+    prompt,
+):
+    import time
+
     from rich import print
     from rich.progress import Progress
     from thefuzz import fuzz
@@ -37,115 +92,237 @@ 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,
+        move_preferred_subtitle_lang_to_top,
+    )
 
     anime_provider = AnimeProvider(config.provider)
+    anilist_anime_info = None
 
     translation_type = config.translation_type
     download_dir = config.downloads_dir
-
-    # ---- search for anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Search Results...", total=None)
-        search_results = anime_provider.search_for_anime(
-            anime_title, translation_type=translation_type
+    if file:
+        contents = file.read()
+        anime_titles_from_file = tuple(
+            [title for title in contents.split("\n") if title]
         )
-    if not search_results:
-        print("Search results failed")
-        input("Enter to retry")
-        download(config, anime_title, episode_range, highest_priority)
-        return
-    search_results = search_results["results"]
-    search_results_ = {
-        search_result["title"]: search_result for search_result in search_results
-    }
+        file.close()
 
-    if config.auto_select:
-        search_result = max(
-            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
-        )
-        print("[cyan]Auto selecting:[/] ", search_result)
-    else:
-        choices = list(search_results_.keys())
-        if config.use_fzf:
-            search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
-        else:
-            search_result = fuzzy_inquirer("Please Select title", choices)
-
-    # ---- fetch anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Anime...", total=None)
-        anime: Anime | None = anime_provider.get_anime(
-            search_results_[search_result]["id"]
-        )
-    if not anime:
-        print("Sth went wring anime no found")
-        input("Enter to continue...")
-        download(config, anime_title, episode_range, highest_priority)
-        return
-
-    episodes = anime["availableEpisodesDetail"][config.translation_type]
-    if episode_range:
-        episodes_start, episodes_end = episode_range.split("-")
-
-    else:
-        episodes_start, episodes_end = 0, len(episodes)
-    for episode in range(round(float(episodes_start)), round(float(episodes_end))):
-        try:
-            episode = str(episode)
-            if episode not in episodes:
-                print(f"[cyan]Warning[/]: Episode {episode} not found, skipping")
-                continue
-            with Progress() as progress:
-                progress.add_task("Fetching Episode Streams...", total=None)
-                streams = anime_provider.get_episode_streams(
-                    anime, episode, config.translation_type
-                )
-                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)
-                    server = next(streams)
-                    link = server["links"][config.quality]["link"]
-                    episode_title = server["episode_title"]
-                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)
-
-            print(f"[purple]Now Downloading:[/] {search_result} Episode {episode}")
-
-            downloader._download_file(
-                link,
-                download_dir,
-                (anime["title"], episode_title),
-                True,
-                config.format,
+        anime_titles = (*anime_titles_from_file, *anime_titles)
+    print(f"[green bold]Queued:[/] {anime_titles}")
+    for anime_title in anime_titles:
+        if anime_title == "EOF":
+            break
+        print(f"[green bold]Now Downloading: [/] {anime_title}")
+        # ---- search for anime ----
+        with Progress() as progress:
+            progress.add_task("Fetching Search Results...", total=None)
+            search_results = anime_provider.search_for_anime(
+                anime_title, translation_type=translation_type
             )
-        except Exception as e:
-            print(e)
-            print("Continuing")
-            clear()
-    print("Done")
+        if not search_results:
+            print("Search results failed")
+            input("Enter to retry")
+            download(
+                config,
+                anime_title,
+                episode_range,
+                file,
+                force_unknown_ext,
+                silent,
+                verbose,
+                merge,
+                clean,
+                wait_time,
+                prompt,
+            )
+            return
+        search_results = search_results["results"]
+        if not search_results:
+            print("Nothing muches your search term")
+            continue
+        search_results_ = {
+            search_result["title"]: search_result for search_result in search_results
+        }
+
+        if config.auto_select:
+            selected_anime_title = max(
+                search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
+            )
+            print("[cyan]Auto selecting:[/] ", selected_anime_title)
+        else:
+            choices = list(search_results_.keys())
+            if config.use_fzf:
+                selected_anime_title = fzf.run(
+                    choices, "Please Select title: ", "FastAnime"
+                )
+            else:
+                selected_anime_title = fuzzy_inquirer(
+                    choices,
+                    "Please Select title",
+                )
+
+        # ---- fetch anime ----
+        with Progress() as progress:
+            progress.add_task("Fetching Anime...", total=None)
+            anime: Anime | None = anime_provider.get_anime(
+                search_results_[selected_anime_title]["id"]
+            )
+        if not anime:
+            print("Sth went wring anime no found")
+            input("Enter to continue...")
+            download(
+                config,
+                anime_title,
+                episode_range,
+                file,
+                force_unknown_ext,
+                silent,
+                verbose,
+                merge,
+                clean,
+                wait_time,
+                prompt,
+            )
+            return
+
+        episodes = sorted(
+            anime["availableEpisodesDetail"][config.translation_type], key=float
+        )
+        # where the magic happens
+        if episode_range:
+            if ":" in episode_range:
+                ep_range_tuple = episode_range.split(":")
+                if len(ep_range_tuple) == 2 and all(ep_range_tuple):
+                    episodes_start, episodes_end = ep_range_tuple
+                    episodes_range = episodes[int(episodes_start) : int(episodes_end)]
+                elif len(ep_range_tuple) == 3 and all(ep_range_tuple):
+                    episodes_start, episodes_end, step = ep_range_tuple
+                    episodes_range = episodes[
+                        int(episodes_start) : int(episodes_end) : int(step)
+                    ]
+                else:
+                    episodes_start, episodes_end = ep_range_tuple
+                    if episodes_start.strip():
+                        episodes_range = episodes[int(episodes_start) :]
+                    elif episodes_end.strip():
+                        episodes_range = episodes[: int(episodes_end)]
+                    else:
+                        episodes_range = episodes
+            else:
+                episodes_range = episodes[int(episode_range) :]
+            print(f"[green bold]Downloading: [/] {episodes_range}")
+
+        else:
+            episodes_range = sorted(episodes, key=float)
+
+        if config.normalize_titles:
+            from ...libs.common.mini_anilist import get_basic_anime_info_by_title
+
+            anilist_anime_info = get_basic_anime_info_by_title(anime["title"])
+
+        # lets download em
+        for episode in episodes_range:
+            try:
+                episode = str(episode)
+                if episode not in episodes:
+                    print(f"[cyan]Warning[/]: Episode {episode} not found, skipping")
+                    continue
+                with Progress() as progress:
+                    progress.add_task("Fetching Episode Streams...", total=None)
+                    streams = anime_provider.get_episode_streams(
+                        anime, episode, config.translation_type
+                    )
+                    if not streams:
+                        print("No streams skipping")
+                        continue
+                # ---- fetch servers ----
+                if config.server == "top":
+                    with Progress() as progress:
+                        progress.add_task("Fetching top server...", total=None)
+                        server_name = next(streams, None)
+                        if not server_name:
+                            print("Sth went wrong when fetching the server")
+                            continue
+                    stream_link = filter_by_quality(
+                        config.quality, server_name["links"]
+                    )
+                    if not stream_link:
+                        print("[yellow bold]WARNING:[/] No streams found")
+                        time.sleep(1)
+                        print("Continuing...")
+                        continue
+                    link = stream_link["link"]
+                    provider_headers = server_name["headers"]
+                    episode_title = server_name["episode_title"]
+                    subtitles = server_name["subtitles"]
+                else:
+                    with Progress() as progress:
+                        progress.add_task("Fetching servers", total=None)
+                        # prompt for server selection
+                        servers = {server["server"]: server for server in streams}
+                    servers_names = list(servers.keys())
+                    if config.server in servers_names:
+                        server_name = config.server
+                    else:
+                        if config.use_fzf:
+                            server_name = fzf.run(servers_names, "Select an link: ")
+                        else:
+                            server_name = fuzzy_inquirer(
+                                servers_names,
+                                "Select link",
+                            )
+                    stream_link = filter_by_quality(
+                        config.quality, servers[server_name]["links"]
+                    )
+                    if not stream_link:
+                        print("[yellow bold]WARNING:[/] No streams found")
+                        time.sleep(1)
+                        print("Continuing...")
+                        continue
+                    link = stream_link["link"]
+                    provider_headers = servers[server_name]["headers"]
+
+                    subtitles = servers[server_name]["subtitles"]
+                    episode_title = servers[server_name]["episode_title"]
+
+                if anilist_anime_info:
+                    selected_anime_title = (
+                        anilist_anime_info["title"][config.preferred_language]
+                        or anilist_anime_info["title"]["romaji"]
+                        or anilist_anime_info["title"]["english"]
+                    )
+                    import re
+
+                    for episode_detail in anilist_anime_info["episodes"]:
+                        if re.match(f"Episode {episode}", episode_detail["title"]):
+                            episode_title = episode_detail["title"]
+                            break
+                print(f"[purple]Now Downloading:[/] {episode_title}")
+                subtitles = move_preferred_subtitle_lang_to_top(
+                    subtitles, config.sub_lang
+                )
+                downloader._download_file(
+                    link,
+                    selected_anime_title,
+                    episode_title,
+                    download_dir,
+                    silent,
+                    config.format,
+                    force_unknown_ext,
+                    verbose,
+                    headers=provider_headers,
+                    sub=subtitles[0]["url"] if subtitles else "",
+                    merge=merge,
+                    clean=clean,
+                    prompt=prompt,
+                )
+            except Exception as e:
+                print(e)
+                time.sleep(1)
+                print("Continuing...")
+    print("Done Downloading")
+    time.sleep(wait_time)
     exit_app()

fastanime/cli/commands/downloads.py

@@ -1,7 +1,9 @@
+import logging
 from typing import TYPE_CHECKING
 
 import click
 
+logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from ..config import Config
 
@@ -10,16 +12,27 @@ if TYPE_CHECKING:
     help="View and watch your downloads using mpv", short_help="Watch downloads"
 )
 @click.option("--path", "-p", help="print the downloads folder and exit", is_flag=True)
+@click.option("--view-episodes", "-v", help="View individual episodes", is_flag=True)
+@click.option(
+    "--ffmpegthumbnailer-seek-time",
+    "--time-to-seek",
+    "-t",
+    type=click.IntRange(-1, 100),
+    help="ffmpegthumbnailer seek time [0-100]",
+)
 @click.pass_obj
-def downloads(config: "Config", path: bool):
+def downloads(config: "Config", path: bool, view_episodes, ffmpegthumbnailer_seek_time):
     import os
 
     from ...cli.utils.mpv import run_mpv
     from ...libs.fzf import fzf
     from ...libs.rofi import Rofi
+    from ...Utility.utils import sort_by_episode_number
     from ..utils.tools import exit_app
     from ..utils.utils import fuzzy_inquirer
 
+    if not ffmpegthumbnailer_seek_time:
+        ffmpegthumbnailer_seek_time = config.ffmpegthumbnailer_seek_time
     USER_VIDEOS_DIR = config.downloads_dir
     if path:
         print(USER_VIDEOS_DIR)
@@ -27,21 +40,273 @@ def downloads(config: "Config", path: bool):
     if not os.path.exists(USER_VIDEOS_DIR):
         print("Downloads directory specified does not exist")
         return
-    playlists = os.listdir(USER_VIDEOS_DIR)
-    playlists.append("Exit")
+    anime_downloads = sorted(
+        os.listdir(USER_VIDEOS_DIR),
+    )
+    anime_downloads.append("Exit")
 
-    def stream():
-        if config.use_fzf:
-            playlist_name = fzf.run(playlists, "Enter Playlist Name", "Downloads")
-        elif config.use_rofi:
-            playlist_name = Rofi.run(playlists, "Enter Playlist Name")
+    def create_thumbnails(video_path, anime_title, downloads_thumbnail_cache_dir):
+        import os
+        import shutil
+        import subprocess
+
+        FFMPEG_THUMBNAILER = shutil.which("ffmpegthumbnailer")
+        if not FFMPEG_THUMBNAILER:
+            return
+
+        out = os.path.join(downloads_thumbnail_cache_dir, anime_title)
+        if ffmpegthumbnailer_seek_time == -1:
+            import random
+
+            seektime = str(random.randrange(0, 100))
         else:
-            playlist_name = fuzzy_inquirer("Enter Playlist Name: ", playlists)
+            seektime = str(ffmpegthumbnailer_seek_time)
+        _ = subprocess.run(
+            [
+                FFMPEG_THUMBNAILER,
+                "-i",
+                video_path,
+                "-o",
+                out,
+                "-s",
+                "0",
+                "-t",
+                seektime,
+            ],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+        )
+
+    def get_previews_anime(workers=None, bg=True):
+        import concurrent.futures
+        import random
+        import shutil
+        from pathlib import Path
+
+        if not shutil.which("ffmpegthumbnailer"):
+            print("ffmpegthumbnailer not found")
+            logger.error("ffmpegthumbnailer not found")
+            return
+
+        from ...constants import APP_CACHE_DIR
+        from ..utils.scripts import fzf_preview
+
+        downloads_thumbnail_cache_dir = os.path.join(APP_CACHE_DIR, "video_thumbnails")
+        Path(downloads_thumbnail_cache_dir).mkdir(parents=True, exist_ok=True)
+
+        def _worker():
+            # 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 anime_downloads:
+                    anime_path = os.path.join(USER_VIDEOS_DIR, anime_title)
+                    if not os.path.isdir(anime_path):
+                        continue
+                    playlist = [
+                        anime
+                        for anime in sorted(
+                            os.listdir(anime_path),
+                        )
+                        if "mp4" in anime
+                    ]
+                    if playlist:
+                        # actual link to download image from
+                        video_path = os.path.join(anime_path, random.choice(playlist))
+                        future_to_url[
+                            executor.submit(
+                                create_thumbnails,
+                                video_path,
+                                anime_title,
+                                downloads_thumbnail_cache_dir,
+                            )
+                        ] = anime_title
+
+                # execute the jobs
+                for future in concurrent.futures.as_completed(future_to_url):
+                    url = future_to_url[future]
+                    try:
+                        future.result()
+                    except Exception as e:
+                        logger.error("%r generated an exception: %s" % (url, e))
+
+        if bg:
+            from threading import Thread
+
+            worker = Thread(target=_worker)
+            worker.daemon = True
+            worker.start()
+        else:
+            _worker()
+        os.environ["SHELL"] = shutil.which("bash") or "bash"
+        preview = """
+            %s
+            if [ -s %s/{} ]; then 
+                if ! fzf-preview %s/{} 2>/dev/null; then
+                    echo Loading...
+                fi
+            else echo Loading...
+            fi
+        """ % (
+            fzf_preview,
+            downloads_thumbnail_cache_dir,
+            downloads_thumbnail_cache_dir,
+        )
+        return preview
+
+    def get_previews_episodes(anime_playlist_path, workers=None, bg=True):
+        import shutil
+        from pathlib import Path
+
+        from ...constants import APP_CACHE_DIR
+        from ..utils.scripts import fzf_preview
+
+        if not shutil.which("ffmpegthumbnailer"):
+            print("ffmpegthumbnailer not found")
+            logger.error("ffmpegthumbnailer not found")
+            return
+
+        downloads_thumbnail_cache_dir = os.path.join(APP_CACHE_DIR, "video_thumbnails")
+        Path(downloads_thumbnail_cache_dir).mkdir(parents=True, exist_ok=True)
+
+        def _worker():
+            import concurrent.futures
+
+            # use concurrency to download the images as fast as possible
+            # anime_playlist_path = os.path.join(USER_VIDEOS_DIR, anime_playlist_path)
+            if not os.path.isdir(anime_playlist_path):
+                return
+            anime_episodes = sorted(
+                os.listdir(anime_playlist_path), key=sort_by_episode_number
+            )
+            with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
+                # load the jobs
+                future_to_url = {}
+                for episode_title in anime_episodes:
+                    episode_path = os.path.join(anime_playlist_path, episode_title)
+
+                    # actual link to download image from
+                    future_to_url[
+                        executor.submit(
+                            create_thumbnails,
+                            episode_path,
+                            episode_title,
+                            downloads_thumbnail_cache_dir,
+                        )
+                    ] = episode_title
+
+                # execute the jobs
+                for future in concurrent.futures.as_completed(future_to_url):
+                    url = future_to_url[future]
+                    try:
+                        future.result()
+                    except Exception as e:
+                        logger.error("%r generated an exception: %s" % (url, e))
+
+        if bg:
+            from threading import Thread
+
+            worker = Thread(target=_worker)
+            worker.daemon = True
+            worker.start()
+        else:
+            _worker()
+        os.environ["SHELL"] = shutil.which("bash") or "bash"
+        preview = """
+            %s
+            if [ -s %s/{} ]; then 
+                if ! fzf-preview %s/{} 2>/dev/null; then
+                    echo Loading...
+                fi
+            else echo Loading...
+            fi
+        """ % (
+            fzf_preview,
+            downloads_thumbnail_cache_dir,
+            downloads_thumbnail_cache_dir,
+        )
+        return preview
+
+    def stream_episode(
+        anime_playlist_path,
+    ):
+        if view_episodes:
+            if not os.path.isdir(anime_playlist_path):
+                print(anime_playlist_path, "is not dir")
+                exit_app(1)
+                return
+            episodes = sorted(
+                os.listdir(anime_playlist_path), key=sort_by_episode_number
+            )
+            downloaded_episodes = [*episodes, "Back"]
+            if config.use_fzf:
+                if not config.preview:
+                    episode_title = fzf.run(
+                        downloaded_episodes,
+                        "Enter Episode ",
+                    )
+                else:
+                    preview = get_previews_episodes(anime_playlist_path)
+                    episode_title = fzf.run(
+                        downloaded_episodes,
+                        "Enter Episode ",
+                        preview=preview,
+                    )
+            elif config.use_rofi:
+                episode_title = Rofi.run(downloaded_episodes, "Enter Episode")
+            else:
+                episode_title = fuzzy_inquirer(
+                    downloaded_episodes,
+                    "Enter Playlist Name: ",
+                )
+            if episode_title == "Back":
+                stream_anime()
+                return
+            episode_path = os.path.join(anime_playlist_path, episode_title)
+            if config.sync_play:
+                from ..utils.syncplay import SyncPlayer
+
+                SyncPlayer(episode_path)
+            else:
+                run_mpv(episode_path)
+            stream_episode(anime_playlist_path)
+
+    def stream_anime():
+        if config.use_fzf:
+            if not config.preview:
+                playlist_name = fzf.run(
+                    anime_downloads,
+                    "Enter Playlist Name",
+                )
+            else:
+                preview = get_previews_anime()
+                playlist_name = fzf.run(
+                    anime_downloads,
+                    "Enter Playlist Name",
+                    preview=preview,
+                )
+        elif config.use_rofi:
+            playlist_name = Rofi.run(anime_downloads, "Enter Playlist Name")
+        else:
+            playlist_name = fuzzy_inquirer(
+                anime_downloads,
+                "Enter Playlist Name: ",
+            )
         if playlist_name == "Exit":
             exit_app()
             return
         playlist = os.path.join(USER_VIDEOS_DIR, playlist_name)
-        run_mpv(playlist)
-        stream()
+        if view_episodes:
+            stream_episode(
+                playlist,
+            )
+        else:
+            if config.sync_play:
+                from ..utils.syncplay import SyncPlayer
 
-    stream()
+                SyncPlayer(playlist)
+            else:
+                run_mpv(playlist)
+        stream_anime()
+
+    stream_anime()

fastanime/cli/commands/grab.py

@@ -0,0 +1,165 @@
+from typing import TYPE_CHECKING
+
+import click
+
+from ..completion_functions import anime_titles_shell_complete
+
+if TYPE_CHECKING:
+    from ..config import Config
+
+
+@click.command(
+    help="Helper command to get streams for anime to use externally in a non-python application",
+    short_help="Print anime streams to standard out",
+)
+@click.option(
+    "--anime-titles",
+    "--anime_title",
+    "-t",
+    required=True,
+    shell_complete=anime_titles_shell_complete,
+    multiple=True,
+    help="Specify which anime to download",
+)
+@click.option(
+    "--episode-range",
+    "-r",
+    help="A range of episodes to download (start-end)",
+)
+@click.option(
+    "--search-results-only",
+    "-s",
+    help="print only the search results to stdout",
+    is_flag=True,
+)
+@click.option(
+    "--anime-info-only", "-i", help="print only selected anime title info", is_flag=True
+)
+@click.option(
+    "--episode-streams-only",
+    "-e",
+    help="print only selected anime episodes streams of given range",
+    is_flag=True,
+)
+@click.pass_obj
+def grab(
+    config: "Config",
+    anime_titles: tuple,
+    episode_range,
+    search_results_only,
+    anime_info_only,
+    episode_streams_only,
+):
+    import json
+    from logging import getLogger
+    from sys import exit
+
+    from thefuzz import fuzz
+
+    from ...AnimeProvider import AnimeProvider
+
+    logger = getLogger(__name__)
+
+    anime_provider = AnimeProvider(config.provider)
+
+    grabbed_animes = []
+    for anime_title in anime_titles:
+        # ---- search for anime ----
+        search_results = anime_provider.search_for_anime(
+            anime_title, translation_type=config.translation_type
+        )
+        if not search_results:
+            exit(1)
+        if search_results_only:
+            # grab only search results skipping all lines after this
+            grabbed_animes.append(search_results)
+            continue
+
+        search_results = search_results["results"]
+        if not search_results:
+            logger.error("no results for your search")
+            exit(1)
+        search_results_ = {
+            search_result["title"]: search_result for search_result in search_results
+        }
+
+        search_result = max(
+            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
+        )
+
+        # ---- fetch anime ----
+        anime = anime_provider.get_anime(search_results_[search_result]["id"])
+        if not anime:
+            exit(1)
+        if anime_info_only:
+            # grab only the anime data skipping all lines after this
+            grabbed_animes.append(anime)
+            continue
+        episodes = sorted(
+            anime["availableEpisodesDetail"][config.translation_type], key=float
+        )
+
+        # where the magic happens
+        if episode_range:
+            if ":" in episode_range:
+                ep_range_tuple = episode_range.split(":")
+                if len(ep_range_tuple) == 2 and all(ep_range_tuple):
+                    episodes_start, episodes_end = ep_range_tuple
+                    episodes_range = episodes[int(episodes_start) : int(episodes_end)]
+                elif len(ep_range_tuple) == 3 and all(ep_range_tuple):
+                    episodes_start, episodes_end, step = ep_range_tuple
+                    episodes_range = episodes[
+                        int(episodes_start) : int(episodes_end) : int(step)
+                    ]
+                else:
+                    episodes_start, episodes_end = ep_range_tuple
+                    if episodes_start.strip():
+                        episodes_range = episodes[int(episodes_start) :]
+                    elif episodes_end.strip():
+                        episodes_range = episodes[: int(episodes_end)]
+                    else:
+                        episodes_range = episodes
+            else:
+                episodes_range = episodes[int(episode_range) :]
+
+        else:
+            episodes_range = sorted(episodes, key=float)
+
+        if not episode_streams_only:
+            grabbed_anime = dict(anime)
+            grabbed_anime["requested_episodes"] = episodes_range
+            grabbed_anime["translation_type"] = config.translation_type
+            grabbed_anime["episodes_streams"] = {}
+        else:
+            grabbed_anime = {}
+
+        # lets download em
+        for episode in episodes_range:
+            try:
+                if episode not in episodes:
+                    continue
+                streams = anime_provider.get_episode_streams(
+                    anime, episode, config.translation_type
+                )
+                if not streams:
+                    continue
+                episode_streams = {server["server"]: server for server in streams}
+
+                if episode_streams_only:
+                    grabbed_anime[episode] = episode_streams
+                else:
+                    grabbed_anime["episodes_streams"][  # pyright:ignore
+                        episode
+                    ] = episode_streams
+
+            except Exception as e:
+                logger.error(e)
+
+        # grab the full data for single title and appen to final result or episode streams
+        grabbed_animes.append(grabbed_anime)
+
+    # print out the final result either {} or [] depending if more than one title os requested
+    if len(grabbed_animes) == 1:
+        print(json.dumps(grabbed_animes[0]))
+    else:
+        print(json.dumps(grabbed_animes))

fastanime/cli/commands/search.py

@@ -1,20 +1,29 @@
 import click
 
 from ...cli.config import Config
+from ..completion_functions import anime_titles_shell_complete
 
 
 @click.command(
     help="This subcommand directly interacts with the provider to enable basic streaming. Useful for binging anime.",
     short_help="Binge anime",
 )
+@click.option(
+    "--anime-titles",
+    "--anime_title",
+    "-t",
+    required=True,
+    shell_complete=anime_titles_shell_complete,
+    multiple=True,
+    help="Specify which anime to download",
+)
 @click.option(
     "--episode-range",
     "-r",
-    help="A range of episodes to binge",
+    help="A range of episodes to binge (start-end)",
 )
-@click.argument("anime_title", required=True, type=str)
 @click.pass_obj
-def search(config: Config, anime_title: str, episode_range: str):
+def search(config: Config, anime_titles: str, episode_range: str):
     from click import clear
     from rich import print
     from rich.progress import Progress
@@ -26,120 +35,224 @@ 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,
+        move_preferred_subtitle_lang_to_top,
+    )
 
     anime_provider = AnimeProvider(config.provider)
+    anilist_anime_info = None
 
-    # ---- search for anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Search Results...", total=None)
-        search_results = anime_provider.search_for_anime(
-            anime_title, config.translation_type
-        )
-    if not search_results:
-        print("Search results not found")
-        input("Enter to retry")
-        search(config, anime_title, episode_range)
-        return
-    search_results = search_results["results"]
-    if not search_results:
-        print("Anime not found :cry:")
-        exit_app()
-    search_results_ = {
-        search_result["title"]: search_result for search_result in search_results
-    }
-
-    if config.auto_select:
-        search_result = max(
-            search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
-        )
-        print("[cyan]Auto Selecting:[/] ", search_result)
-
-    else:
-        choices = list(search_results_.keys())
-        if config.use_fzf:
-            search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
-        elif config.use_rofi:
-            search_result = Rofi.run(choices, "Please Select Title")
-        else:
-            search_result = fuzzy_inquirer(
-                "Please Select Title",
-                choices,
-            )
-
-    # ---- fetch selected anime ----
-    with Progress() as progress:
-        progress.add_task("Fetching Anime...", total=None)
-        anime: Anime | None = anime_provider.get_anime(
-            search_results_[search_result]["id"]
-        )
-
-    if not anime:
-        print("Sth went wring anime no found")
-        input("Enter to continue...")
-        search(config, anime_title, episode_range)
-        return
-    episode_range_ = None
-    episodes = anime["availableEpisodesDetail"][config.translation_type]
-    if episode_range:
-        episodes_start, episodes_end = episode_range.split("-")
-        if episodes_start and episodes_end:
-            episode_range_ = iter(
-                range(round(float(episodes_start)), round(float(episodes_end)) + 1)
-            )
-        else:
-            episode_range_ = iter(sorted(episodes, key=float))
-
-    def stream_anime():
-        clear()
-        episode = None
-
-        if episode_range_:
-            try:
-                episode = str(next(episode_range_))
-                print(
-                    f"[cyan]Auto selecting:[/] {search_result} [cyan]Episode:[/] {episode}"
-                )
-            except StopIteration:
-                print("[green]Completed binge sequence[/]:smile:")
-
-        if not episode or episode not in episodes:
-            if config.use_fzf:
-                episode = fzf.run(episodes, "Select an episode: ", header=search_result)
-            elif config.use_rofi:
-                episode = Rofi.run(episodes, "Select an episode")
-            else:
-                episode = fuzzy_inquirer("Select episode", episodes)
-
-        # ---- fetch streams ----
+    print(f"[green bold]Streaming:[/] {anime_titles}")
+    for anime_title in anime_titles:
+        # ---- search for anime ----
         with Progress() as progress:
-            progress.add_task("Fetching Episode Streams...", total=None)
-            streams = anime_provider.get_episode_streams(
-                anime, episode, config.translation_type
+            progress.add_task("Fetching Search Results...", total=None)
+            search_results = anime_provider.search_for_anime(
+                anime_title, config.translation_type
             )
-            if not streams:
-                print("Failed to get streams")
+        if not search_results:
+            print("Search results not found")
+            input("Enter to retry")
+            search(config, anime_title, episode_range)
+            return
+        search_results = search_results["results"]
+        if not search_results:
+            print("Anime not found :cry:")
+            exit_app()
+        search_results_ = {
+            search_result["title"]: search_result for search_result in search_results
+        }
+
+        if config.auto_select:
+            search_result = max(
+                search_results_.keys(), key=lambda title: fuzz.ratio(title, anime_title)
+            )
+            print("[cyan]Auto Selecting:[/] ", search_result)
+
+        else:
+            choices = list(search_results_.keys())
+            if config.use_fzf:
+                search_result = fzf.run(choices, "Please Select title: ", "FastAnime")
+            elif config.use_rofi:
+                search_result = Rofi.run(choices, "Please Select Title")
+            else:
+                search_result = fuzzy_inquirer(
+                    choices,
+                    "Please Select Title",
+                )
+
+        # ---- fetch selected anime ----
+        with Progress() as progress:
+            progress.add_task("Fetching Anime...", total=None)
+            anime: Anime | None = anime_provider.get_anime(
+                search_results_[search_result]["id"]
+            )
+
+        if not anime:
+            print("Sth went wring anime no found")
+            input("Enter to continue...")
+            search(config, anime_title, episode_range)
+            return
+        episodes_range = []
+        episodes: list[str] = sorted(
+            anime["availableEpisodesDetail"][config.translation_type], key=float
+        )
+        if episode_range:
+            if ":" in episode_range:
+                ep_range_tuple = episode_range.split(":")
+                if len(ep_range_tuple) == 3 and all(ep_range_tuple):
+                    episodes_start, episodes_end, step = ep_range_tuple
+                    episodes_range = episodes[
+                        int(episodes_start) : int(episodes_end) : int(step)
+                    ]
+
+                elif len(ep_range_tuple) == 2 and all(ep_range_tuple):
+                    episodes_start, episodes_end = ep_range_tuple
+                    episodes_range = episodes[int(episodes_start) : int(episodes_end)]
+                else:
+                    episodes_start, episodes_end = ep_range_tuple
+                    if episodes_start.strip():
+                        episodes_range = episodes[int(episodes_start) :]
+                    elif episodes_end.strip():
+                        episodes_range = episodes[: int(episodes_end)]
+                    else:
+                        episodes_range = episodes
+            else:
+                episodes_range = episodes[int(episode_range) :]
+
+            episodes_range = iter(episodes_range)
+
+        if config.normalize_titles:
+            from ...libs.common.mini_anilist import get_basic_anime_info_by_title
+
+            anilist_anime_info = get_basic_anime_info_by_title(anime["title"])
+
+        def stream_anime():
+            clear()
+            episode = None
+
+            if episodes_range:
+                try:
+                    episode = next(episodes_range)  # pyright:ignore
+                    print(
+                        f"[cyan]Auto selecting:[/] {search_result} [cyan]Episode:[/] {episode}"
+                    )
+                except StopIteration:
+                    print("[green]Completed binge sequence[/]:smile:")
+                    return
+
+            if not episode or episode not in episodes:
+                choices = [*episodes, "end"]
+                if config.use_fzf:
+                    episode = fzf.run(
+                        choices, "Select an episode: ", header=search_result
+                    )
+                elif config.use_rofi:
+                    episode = Rofi.run(choices, "Select an episode")
+                else:
+                    episode = fuzzy_inquirer(
+                        choices,
+                        "Select episode",
+                    )
+            if episode == "end":
                 return
 
-        # ---- fetch servers ----
-        with Progress() as progress:
-            if config.server == "top":
-                progress.add_task("Fetching top server...", total=None)
-                server = next(streams)
-                link = server["links"][config.quality]["link"]
-            else:
-                progress.add_task("Fetching servers", total=None)
-                links = [link["link"] for server in streams for link in server["links"]]
-                if config.use_fzf:
-                    link = fzf.run(links, "Select an link: ", header=search_result)
-                elif config.use_rofi:
-                    link = Rofi.run(links, "Select an link")
+            # ---- fetch streams ----
+            with Progress() as progress:
+                progress.add_task("Fetching Episode Streams...", total=None)
+                streams = anime_provider.get_episode_streams(
+                    anime, episode, config.translation_type
+                )
+                if not streams:
+                    print("Failed to get streams")
+                    return
+
+            try:
+                # ---- fetch servers ----
+                if config.server == "top":
+                    with Progress() as progress:
+                        progress.add_task("Fetching top server...", total=None)
+                        server = next(streams, None)
+                        if not server:
+                            print("Sth went wrong when fetching the episode")
+                            input("Enter to continue")
+                            stream_anime()
+                            return
+                    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"]
+                    subtitles = server["subtitles"]
+                    stream_headers = server["headers"]
+                    episode_title = server["episode_title"]
                 else:
-                    link = fuzzy_inquirer("Select link", 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.server in servers_names:
+                        server = config.server
+                    else:
+                        if config.use_fzf:
+                            server = fzf.run(servers_names, "Select an link: ")
+                        elif config.use_rofi:
+                            server = Rofi.run(servers_names, "Select an link")
+                        else:
+                            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"]
+                    stream_headers = servers[server]["headers"]
+                    subtitles = servers[server]["subtitles"]
+                    episode_title = servers[server]["episode_title"]
 
-        print(f"[purple]Now Playing:[/] {search_result} Episode {episode}")
+                selected_anime_title = search_result
+                if anilist_anime_info:
+                    selected_anime_title = (
+                        anilist_anime_info["title"][config.preferred_language]
+                        or anilist_anime_info["title"]["romaji"]
+                        or anilist_anime_info["title"]["english"]
+                    )
+                    import re
+
+                    for episode_detail in anilist_anime_info["episodes"]:
+                        if re.match(f"Episode {episode}", episode_detail["title"]):
+                            episode_title = episode_detail["title"]
+                            break
+                print(
+                    f"[purple]Now Playing:[/] {selected_anime_title} Episode {episode}"
+                )
+                subtitles = move_preferred_subtitle_lang_to_top(
+                    subtitles, config.sub_lang
+                )
+                if config.sync_play:
+                    from ..utils.syncplay import SyncPlayer
+
+                    SyncPlayer(
+                        link, episode_title, headers=stream_headers, subtitles=subtitles
+                    )
+                else:
+                    run_mpv(
+                        link, episode_title, headers=stream_headers, subtitles=subtitles
+                    )
+            except IndexError as e:
+                print(e)
+                input("Enter to continue")
+            stream_anime()
 
-        run_mpv(link, search_result)
         stream_anime()
-
-    stream_anime()

fastanime/cli/commands/update.py

@@ -0,0 +1,42 @@
+import click
+
+
+@click.command(help="Helper command to update fastanime to latest")
+@click.option("--check", "-c", help="Check for the latest release", is_flag=True)
+def update(
+    check,
+):
+    from rich.console import Console
+    from rich.markdown import Markdown
+
+    from ... import __version__
+    from ..app_updater import check_for_updates, update_app
+
+    def _print_release(release_data):
+        console = Console()
+        body = Markdown(release_data["body"])
+        tag = github_release_data["tag_name"]
+        tag_title = release_data["name"]
+        github_page_url = release_data["html_url"]
+        console.print(f"Release Page: {github_page_url}")
+        console.print(f"Tag: {tag}")
+        console.print(f"Title: {tag_title}")
+        console.print(body)
+
+    if check:
+        is_latest, github_release_data = check_for_updates()
+        if not is_latest:
+            print(
+                f"You are running an older version ({__version__}) of fastanime please update to get the latest features"
+            )
+            _print_release(github_release_data)
+        else:
+            print(f"You are running the latest version ({__version__}) of fastanime")
+            _print_release(github_release_data)
+    else:
+        success, github_release_data = update_app()
+        _print_release(github_release_data)
+        if success:
+            print("Successfully updated")
+        else:
+            print("failed to update")

fastanime/cli/completion_functions.py

@@ -0,0 +1,79 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+ANILIST_ENDPOINT = "https://graphql.anilist.co"
+
+
+anime_title_query = """
+query($query:String){
+    Page(perPage:50){
+        pageInfo{
+            total
+        }
+        media(search:$query,type:ANIME){
+            id
+                idMal
+            title{
+                romaji
+                english
+            }
+        }
+    }
+}
+"""
+
+
+def get_anime_titles(query: str, variables: dict = {}):
+    """the abstraction over all none authenticated requests and that returns data of a similar type
+
+    Args:
+        query: the anilist query
+        variables: the anilist api variables
+
+    Returns:
+        a boolean indicating success and none or an anilist object depending on success
+    """
+    from requests import post
+
+    try:
+        response = post(
+            ANILIST_ENDPOINT,
+            json={"query": query, "variables": variables},
+            timeout=10,
+        )
+        anilist_data = response.json()
+
+        if response.status_code == 200:
+            eng_titles = [
+                anime["title"]["english"]
+                for anime in anilist_data["data"]["Page"]["media"]
+                if anime["title"]["english"]
+            ]
+            romaji_titles = [
+                anime["title"]["romaji"]
+                for anime in anilist_data["data"]["Page"]["media"]
+                if anime["title"]["romaji"]
+            ]
+            return [*eng_titles, *romaji_titles]
+        else:
+            return []
+    except Exception as e:
+        logger.error(f"Something unexpected occured {e}")
+        return []
+
+
+def anime_titles_shell_complete(ctx, param, incomplete):
+    incomplete = incomplete.strip()
+    if not incomplete:
+        incomplete = None
+        variables = {}
+    else:
+        variables = {"query": incomplete}
+    return get_anime_titles(anime_title_query, variables)
+
+
+if __name__ == "__main__":
+    t = input("Enter title")
+    results = get_anime_titles(anime_title_query, {"query": t})
+    print(results)

fastanime/cli/config.py

@@ -1,39 +1,87 @@
+import json
+import logging
 import os
 from configparser import ConfigParser
 from typing import TYPE_CHECKING
 
 from rich import print
 
-from ..constants import USER_CONFIG_PATH, USER_VIDEOS_DIR
+from ..constants import USER_CONFIG_PATH, USER_DATA_PATH, USER_VIDEOS_DIR
 from ..libs.rofi import Rofi
-from ..Utility.user_data_helper import user_data_helper
 
+logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from ..AnimeProvider import AnimeProvider
 
 
 class Config(object):
+    """class that handles and manages configuration and user data throughout the clis lifespan
+
+    Attributes:
+        anime_list: [TODO:attribute]
+        watch_history: [TODO:attribute]
+        fastanime_anilist_app_login_url: [TODO:attribute]
+        anime_provider: [TODO:attribute]
+        user_data: [TODO:attribute]
+        configparser: [TODO:attribute]
+        downloads_dir: [TODO:attribute]
+        provider: [TODO:attribute]
+        use_fzf: [TODO:attribute]
+        use_rofi: [TODO:attribute]
+        skip: [TODO:attribute]
+        icons: [TODO:attribute]
+        preview: [TODO:attribute]
+        translation_type: [TODO:attribute]
+        sort_by: [TODO:attribute]
+        continue_from_history: [TODO:attribute]
+        auto_next: [TODO:attribute]
+        auto_select: [TODO:attribute]
+        use_mpv_mod: [TODO:attribute]
+        quality: [TODO:attribute]
+        notification_duration: [TODO:attribute]
+        error: [TODO:attribute]
+        server: [TODO:attribute]
+        format: [TODO:attribute]
+        force_window: [TODO:attribute]
+        preferred_language: [TODO:attribute]
+        rofi_theme: [TODO:attribute]
+        rofi_theme: [TODO:attribute]
+        rofi_theme_input: [TODO:attribute]
+        rofi_theme_input: [TODO:attribute]
+        rofi_theme_confirm: [TODO:attribute]
+        rofi_theme_confirm: [TODO:attribute]
+        watch_history: [TODO:attribute]
+        anime_list: [TODO:attribute]
+        user: [TODO:attribute]
+    """
+
+    sync_play = False
     anime_list: list
     watch_history: dict
     fastanime_anilist_app_login_url = (
         "https://anilist.co/api/v2/oauth/authorize?client_id=20148&response_type=token"
     )
     anime_provider: "AnimeProvider"
+    user_data = {"watch_history": {}, "animelist": [], "user": {}}
 
     def __init__(self) -> None:
+        self.initialize_user_data()
         self.load_config()
 
     def load_config(self):
         self.configparser = ConfigParser(
             {
-                "server": "top",
-                "continue_from_history": "True",
-                "quality": "0",
+                "quality": "1080",
                 "auto_next": "False",
                 "auto_select": "True",
                 "sort_by": "search match",
                 "downloads_dir": USER_VIDEOS_DIR,
                 "translation_type": "sub",
+                "server": "top",
+                "continue_from_history": "True",
+                "preferred_history": "local",
+                "use_mpv_mod": "false",
+                "force_window": "immediate",
                 "preferred_language": "english",
                 "use_fzf": "False",
                 "preview": "False",
@@ -47,7 +95,9 @@ class Config(object):
                 "rofi_theme": "",
                 "rofi_theme_input": "",
                 "rofi_theme_confirm": "",
-                "use_mpv_mod": "true",
+                "ffmpegthumnailer_seek_time": "-1",
+                "sub_lang": "eng",
+                "normalize_titles": "true",
             }
         )
         self.configparser.add_section("stream")
@@ -59,8 +109,9 @@ class Config(object):
 
         self.configparser.read(USER_CONFIG_PATH)
 
-        # --- set defaults ---
+        # --- set config values from file or using defaults ---
         self.downloads_dir = self.get_downloads_dir()
+        self.sub_lang = self.get_sub_lang()
         self.provider = self.get_provider()
         self.use_fzf = self.get_use_fzf()
         self.use_rofi = self.get_use_rofi()
@@ -71,6 +122,7 @@ class Config(object):
         self.sort_by = self.get_sort_by()
         self.continue_from_history = self.get_continue_from_history()
         self.auto_next = self.get_auto_next()
+        self.normalize_titles = self.get_normalize_titles()
         self.auto_select = self.get_auto_select()
         self.use_mpv_mod = self.get_use_mpv_mod()
         self.quality = self.get_quality()
@@ -78,24 +130,28 @@ class Config(object):
         self.error = self.get_error()
         self.server = self.get_server()
         self.format = self.get_format()
+        self.force_window = self.get_force_window()
         self.preferred_language = self.get_preferred_language()
+        self.preferred_history = self.get_preferred_history()
         self.rofi_theme = self.get_rofi_theme()
         Rofi.rofi_theme = self.rofi_theme
         self.rofi_theme_input = self.get_rofi_theme_input()
         Rofi.rofi_theme_input = self.rofi_theme_input
         self.rofi_theme_confirm = self.get_rofi_theme_confirm()
         Rofi.rofi_theme_confirm = self.rofi_theme_confirm
+        self.ffmpegthumbnailer_seek_time = self.get_ffmpegthumnailer_seek_time()
         # ---- setup user data ------
-        self.watch_history: dict = user_data_helper.user_data.get("watch_history", {})
-        self.anime_list: list = user_data_helper.user_data.get("animelist", [])
-        self.user: dict = user_data_helper.user_data.get("user", {})
+        self.watch_history: dict = self.user_data.get("watch_history", {})
+        self.anime_list: list = self.user_data.get("animelist", [])
+        self.user: dict = self.user_data.get("user", {})
 
     def update_user(self, user):
         self.user = user
-        user_data_helper.update_user_info(user)
+        self.user_data["user"] = user
+        self._update_user_data()
 
     def update_watch_history(
-        self, anime_id: int, episode: str | None, start_time="0", total_time="0"
+        self, anime_id: int, episode: str, start_time="0", total_time="0"
     ):
         self.watch_history.update(
             {
@@ -106,24 +162,54 @@ class Config(object):
                 }
             }
         )
-        user_data_helper.update_watch_history(self.watch_history)
+        self.user_data["watch_history"] = self.watch_history
+        self._update_user_data()
 
-    def update_anime_list(self, anime_id: int, remove=False):
-        if remove:
-            try:
-                self.anime_list.remove(anime_id)
-                print("Succesfully removed :cry:")
-            except Exception:
-                print(anime_id, "Nothing to remove :confused:")
-        else:
-            self.anime_list.append(anime_id)
-            user_data_helper.update_animelist(self.anime_list)
-            print("Succesfully added :smile:")
-        input("Enter to continue...")
+    def initialize_user_data(self):
+        try:
+            if os.path.isfile(USER_DATA_PATH):
+                with open(USER_DATA_PATH, "r") as f:
+                    user_data = json.load(f)
+                    self.user_data.update(user_data)
+        except Exception as e:
+            logger.error(e)
 
+    def _update_user_data(self):
+        """method that updates the actual user data file"""
+        with open(USER_DATA_PATH, "w") as f:
+            json.dump(self.user_data, f)
+
+    # getters for user configuration
+
+    # --- general section ---
     def get_provider(self):
         return self.configparser.get("general", "provider")
 
+    def get_ffmpegthumnailer_seek_time(self):
+        return self.configparser.getint("general", "ffmpegthumnailer_seek_time")
+
+    def get_preferred_language(self):
+        return self.configparser.get("general", "preferred_language")
+
+    def get_sub_lang(self):
+        return self.configparser.get("general", "sub_lang")
+
+    def get_downloads_dir(self):
+        return self.configparser.get("general", "downloads_dir")
+
+    def get_icons(self):
+        return self.configparser.getboolean("general", "icons")
+
+    def get_preview(self):
+        return self.configparser.getboolean("general", "preview")
+
+    def get_use_fzf(self):
+        return self.configparser.getboolean("general", "use_fzf")
+
+    # rofi conifiguration
+    def get_use_rofi(self):
+        return self.configparser.getboolean("general", "use_rofi")
+
     def get_rofi_theme(self):
         return self.configparser.get("general", "rofi_theme")
 
@@ -133,44 +219,21 @@ class Config(object):
     def get_rofi_theme_confirm(self):
         return self.configparser.get("general", "rofi_theme_confirm")
 
-    def get_downloads_dir(self):
-        return self.configparser.get("general", "downloads_dir")
-
-    def get_use_fzf(self):
-        return self.configparser.getboolean("general", "use_fzf")
-
-    def get_use_rofi(self):
-        return self.configparser.getboolean("general", "use_rofi")
+    def get_normalize_titles(self):
+        return self.configparser.getboolean("general", "normalize_titles")
 
+    # --- stream section ---
     def get_skip(self):
         return self.configparser.getboolean("stream", "skip")
 
-    def get_icons(self):
-        return self.configparser.getboolean("general", "icons")
-
-    def get_preview(self):
-        return self.configparser.getboolean("general", "preview")
-
-    def get_preferred_language(self):
-        return self.configparser.get("general", "preferred_language")
-
-    def get_sort_by(self):
-        return self.configparser.get("anilist", "sort_by")
-
-    def get_continue_from_history(self):
-        return self.configparser.getboolean("stream", "continue_from_history")
-
-    def get_translation_type(self):
-        return self.configparser.get("stream", "translation_type")
-
     def get_auto_next(self):
         return self.configparser.getboolean("stream", "auto_next")
 
     def get_auto_select(self):
         return self.configparser.getboolean("stream", "auto_select")
 
-    def get_quality(self):
-        return self.configparser.getint("stream", "quality")
+    def get_continue_from_history(self):
+        return self.configparser.getboolean("stream", "continue_from_history")
 
     def get_use_mpv_mod(self):
         return self.configparser.getboolean("stream", "use_mpv_mod")
@@ -181,19 +244,138 @@ class Config(object):
     def get_error(self):
         return self.configparser.getint("stream", "error")
 
+    def get_force_window(self):
+        return self.configparser.get("stream", "force_window")
+
+    def get_translation_type(self):
+        return self.configparser.get("stream", "translation_type")
+
+    def get_preferred_history(self):
+        return self.configparser.get("stream", "preferred_history")
+
+    def get_quality(self):
+        return self.configparser.get("stream", "quality")
+
     def get_server(self):
         return self.configparser.get("stream", "server")
 
     def get_format(self):
         return self.configparser.get("stream", "format")
 
+    def get_sort_by(self):
+        return self.configparser.get("anilist", "sort_by")
+
     def update_config(self, section: str, key: str, value: str):
         self.configparser.set(section, key, value)
         with open(USER_CONFIG_PATH, "w") as config:
             self.configparser.write(config)
 
     def __repr__(self):
-        return f"Config(server:{self.get_server()},quality:{self.get_quality()},auto_next:{self.get_auto_next()},continue_from_history:{self.get_continue_from_history()},sort_by:{self.get_sort_by()},downloads_dir:{self.get_downloads_dir()})"
+        current_config_state = f"""
+[stream]
+# Auto continue from watch history
+continue_from_history = {self.continue_from_history}  
+
+# which hostory to use [local/remote]
+preferred_history = {self.preferred_history}
+
+
+# Preferred language for anime (options: dub, sub)
+translation_type = {self.translation_type}
+
+# Default server (options: dropbox, sharepoint, wetransfer.gogoanime, top, wixmp)
+server = {self.server}
+
+# Auto-select next episode
+auto_next = {self.auto_next}
+
+# Auto select the anime provider results with fuzzy find.
+# Note this wont always be correct.But 99% of the time will be.
+auto_select = {self.auto_select}
+
+# whether to skip the opening and ending theme songs
+# NOTE: requires ani-skip to be in path
+skip = {self.skip}
+
+# the maximum delta time in minutes after which the episode should be considered as completed
+# used in the continue from time stamp
+error = {self.error}
+
+# whether to use python-mpv
+# to enable superior control over the player 
+# adding more options to it
+use_mpv_mod = {self.use_mpv_mod}
+
+# force mpv window
+# passed directly to mpv so values are same
+force_window = immediate
+
+# the format of downloaded anime and trailer
+# based on yt-dlp format and passed directly to it
+# learn more by looking it up on their site
+# only works for downloaded anime if server=gogoanime
+# since its the only one that offers different formats
+# the others tend not to
+format = {self.format}
+
+[general]
+
+# whether to normalize provider titles
+normalize_titles = {self.normalize_titles}
+
+# can be [allanime,animepahe]
+provider = {self.provider}
+
+# Display language (options: english, romaji)
+preferred_language = {self.preferred_language}
+
+# Download directory
+downloads_dir = {self.downloads_dir}
+
+# whether to show a preview window when using fzf or rofi
+preview = {self.preview} 
+
+# the time to seek when using ffmpegthumbnailer [-1 to 100]
+# -1 means random and is the default
+ffmpegthumbnailer_seek_time = {self.ffmpegthumbnailer_seek_time}
+
+# whether to use fzf as the interface for the anilist command and others.
+use_fzf = {self.use_fzf} 
+
+# whether to use rofi for the ui
+use_rofi = {self.use_rofi}
+
+# rofi theme to use
+rofi_theme = {self.rofi_theme}
+
+rofi_theme_input = {self.rofi_theme_input}
+
+rofi_theme_confirm = {self.rofi_theme_confirm}
+
+
+# whether to show the icons
+icons = {self.icons}
+
+# the duration in minutes a notification will stay in the screen
+# used by notifier command
+notification_duration = {self.notification_duration}
+        """
+        return current_config_state
 
     def __str__(self):
         return self.__repr__()
+
+    # WARNING: depracated and will probably be removed
+    def update_anime_list(self, anime_id: int, remove=False):
+        if remove:
+            try:
+                self.anime_list.remove(anime_id)
+                print("Succesfully removed :cry:")
+            except Exception:
+                print(anime_id, "Nothing to remove :confused:")
+        else:
+            self.anime_list.append(anime_id)
+            self.user_data["animelist"] = list(set(self.anime_list))
+            self._update_user_data()
+            print("Succesfully added :smile:")
+            input("Enter to continue...")

fastanime/cli/interfaces/utils.py

@@ -7,95 +7,28 @@ import textwrap
 from threading import Thread
 
 import requests
+from yt_dlp.utils import clean_html
 
 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.scripts import fzf_preview
 from ..utils.utils import get_true_fg
 
 logger = logging.getLogger(__name__)
 
-fzf_preview = r"""
-#
-# The purpose of this script is to demonstrate how to preview a file or an
-# image in the preview window of fzf.
-#
-# Dependencies:
-# - https://github.com/sharkdp/bat
-# - https://github.com/hpjansson/chafa
-# - https://iterm2.com/utilities/imgcat
-fzf-preview(){
-    if [[ $# -ne 1 ]]; then
-    >&2 echo "usage: $0 FILENAME"
-    exit 1
-    fi
-
-    file=${1/#\~\//$HOME/}
-    type=$(file --dereference --mime -- "$file")
-
-    if [[ ! $type =~ image/ ]]; then
-    if [[ $type =~ =binary ]]; then
-        file "$1"
-        exit
-    fi
-
-    # Sometimes bat is installed as batcat.
-    if command -v batcat > /dev/null; then
-        batname="batcat"
-    elif command -v bat > /dev/null; then
-        batname="bat"
-    else
-        cat "$1"
-        exit
-    fi
-
-    ${batname} --style="${BAT_STYLE:-numbers}" --color=always --pager=never -- "$file"
-    exit
-    fi
-
-    dim=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}
-    if [[ $dim = x ]]; then
-    dim=$(stty size < /dev/tty | awk '{print $2 "x" $1}')
-    elif ! [[ $KITTY_WINDOW_ID ]] && (( FZF_PREVIEW_TOP + FZF_PREVIEW_LINES == $(stty size < /dev/tty | awk '{print $1}') )); then
-    # Avoid scrolling issue when the Sixel image touches the bottom of the screen
-    # * https://github.com/junegunn/fzf/issues/2544
-    dim=${FZF_PREVIEW_COLUMNS}x$((FZF_PREVIEW_LINES - 1))
-    fi
-
-# 1. Use kitty icat on kitty terminal
-    if [[ $KITTY_WINDOW_ID ]]; then
-    # 1. 'memory' is the fastest option but if you want the image to be scrollable,
-    #    you have to use 'stream'.
-    #
-    # 2. The last line of the output is the ANSI reset code without newline.
-    #    This confuses fzf and makes it render scroll offset indicator.
-    #    So we remove the last line and append the reset code to its previous line.
-    kitty icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place="$dim@0x0" "$file" | sed '$d' | sed $'$s/$/\e[m/'
-
-# 2. Use chafa with Sixel output
-    elif command -v chafa > /dev/null; then
-    chafa -f sixel -s "$dim" "$file"
-    # Add a new line character so that fzf can display multiple images in the preview window
-    echo
-
-# 3. If chafa is not found but imgcat is available, use it on iTerm2
-    elif command -v imgcat > /dev/null; then
-    # NOTE: We should use https://iterm2.com/utilities/it2check to check if the
-    # user is running iTerm2. But for the sake of simplicity, we just assume
-    # that's the case here.
-    imgcat -W "${dim%%x*}" -H "${dim##*x}" "$file"
-
-# 4. Cannot find any suitable method to preview the image
-    else
-    file "$file"
-    fi
-}
-"""
-
 
 # ---- 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 +44,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,24 +106,24 @@ 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"""
             {template}
-            {textwrap.fill(remove_html_tags(
+            {textwrap.fill(clean_html(
                 str(anime['description'])), width=45)}
             """
             future_to_task[executor.submit(save_info_from_str, template, title)] = title
@@ -181,11 +138,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 +164,72 @@ 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):
-    # ensure images and info exists
+# get rofi icons
+def get_fzf_episode_preview(
+    anilist_result: AnilistBaseMediaDataSchema, episodes, workers=None, wait=False
+):
+    """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
+    """
+
+    HEADER_COLOR = 215, 0, 95
+    import re
+
+    def _worker():
+        # 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 episode in episodes:
+                episode_title = ""
+                image_url = ""
+                for episode_detail in anilist_result["streamingEpisodes"]:
+                    if re.match(f"Episode {episode}", episode_detail["title"]):
+                        episode_title = episode_detail["title"]
+                        image_url = episode_detail["thumbnail"]
+
+                if episode_title and image_url:
+                    # actual link to download image from
+                    if not image_url:
+                        continue
+                    future_to_url[
+                        executor.submit(save_image_from_url, image_url, episode)
+                    ] = image_url
+                    template = textwrap.dedent(
+                        f"""
+                    {get_true_fg('Anime Title:',*HEADER_COLOR)} {anilist_result['title']['romaji'] or anilist_result['title']['english']}
+                    {get_true_fg('Episode Title:',*HEADER_COLOR)} {episode_title}
+                    """
+                    )
+                    future_to_url[
+                        executor.submit(save_info_from_str, template, episode)
+                    ] = episode_title
+
+            # execute the jobs
+            for future in concurrent.futures.as_completed(future_to_url):
+                url = future_to_url[future]
+                try:
+                    future.result()
+                except Exception as e:
+                    logger.error("%r generated an exception: %s" % (url, e))
+
     background_worker = Thread(
-        target=write_search_results, args=(search_results, titles)
+        target=_worker,
     )
+    # ensure images and info exists
     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 +240,53 @@ 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,
+    )
+    if wait:
+        background_worker.join()
+    return preview
+
+
+def get_fzf_anime_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=(anilist_results, titles)
+    )
+    background_worker.daemon = True
+    background_worker.start()
+
+    # 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/{}
+        else echo Loading...
+        fi
+        if [ -s %s/{} ]; then cat %s/{}
+        else echo Loading...
+        fi
+    """ % (
+        fzf_preview,
+        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/mpv.py

@@ -2,6 +2,8 @@ import re
 import shutil
 import subprocess
 
+from fastanime.constants import S_PLATFORM
+
 
 def stream_video(MPV, url, mpv_args, custom_args):
     process = subprocess.Popen(
@@ -52,6 +54,8 @@ def run_mpv(
     start_time: str = "0",
     ytdl_format="",
     custom_args=[],
+    headers={},
+    subtitles=[],
 ):
     # Determine if mpv is available
     MPV = shutil.which("mpv")
@@ -61,7 +65,7 @@ def run_mpv(
     # Regex to check if the link is a YouTube URL
     youtube_regex = r"(https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/.+"
 
-    if not MPV:
+    if not MPV and not S_PLATFORM == "win32":
         # Determine if the link is a YouTube URL
         if re.match(youtube_regex, link):
             # Android specific commands to launch mpv with a YouTube URL
@@ -100,6 +104,13 @@ def run_mpv(
     else:
         # General mpv command with custom arguments
         mpv_args = []
+        if headers:
+            mpv_headers = "--http-header-fields="
+            for header_name, header_value in headers.items():
+                mpv_headers += f"{header_name}:{header_value},"
+            mpv_args.append(mpv_headers)
+        for subtitle in subtitles:
+            mpv_args.append(f"--sub-file={subtitle['url']}")
         if start_time != "0":
             mpv_args.append(f"--start={start_time}")
         if title:

fastanime/cli/utils/player.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING
 import mpv
 
 from ...anilist import AniList
+from .utils import filter_by_quality, move_preferred_subtitle_lang_to_top
 
 if TYPE_CHECKING:
     from typing import Literal
@@ -21,23 +22,32 @@ def format_time(duration_in_secs: float):
 class MpvPlayer(object):
     anime_provider: "AnimeProvider"
     config: "Config"
+    subs = []
     mpv_player: "mpv.MPV"
     last_stop_time: str = "0"
     last_total_time: str = "0"
     last_stop_time_secs = 0
     last_total_time_secs = 0
     current_media_title = ""
+    player_fetching = False
 
     def get_episode(
-        self, type: "Literal['next','previous','reload','custom']", ep_no=None
+        self,
+        type: "Literal['next','previous','reload','custom']",
+        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"
@@ -48,70 +58,122 @@ 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}")
+                self.mpv_player.show_text(
+                    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": int(float(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")
-            return None
+            return
 
         # always select the first
-        selected_server = next(episode_streams)
+        if server == "top":
+            selected_server = next(episode_streams, None)
+            if not selected_server:
+                self.mpv_player.show_text("Sth went wrong when loading the episode")
+                return
+        else:
+            episode_streams_dict = {
+                episode_stream["server"]: episode_stream
+                for episode_stream in episode_streams
+            }
+            selected_server = episode_streams_dict.get(server)
+            if selected_server is None:
+                self.mpv_player.show_text(
+                    f"Invalid server!!; servers available are: {episode_streams_dict.keys()}",
+                )
+                return
         self.current_media_title = selected_server["episode_title"]
+        if config.normalize_titles:
+            import re
+
+            for episode_detail in fastanime_runtime_state.selected_anime_anilist[
+                "streamingEpisodes"
+            ]:
+                if re.match(
+                    f"Episode {current_episode_number}", episode_detail["title"]
+                ):
+                    self.current_media_title = episode_detail["title"]
+                    break
+
         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
+        self.mpv_player._set_property("start", "0")
+        stream_link = stream_link_["link"]
+        fastanime_runtime_state.provider_current_episode_stream_link = stream_link
+        self.subs = move_preferred_subtitle_lang_to_top(
+            selected_server["subtitles"], config.sub_lang
+        )
         return stream_link
 
     def create_player(
-        self, anime_provider: "AnimeProvider", anilist_config, config: "Config", title
+        self,
+        stream_link,
+        anime_provider: "AnimeProvider",
+        fastanime_runtime_state,
+        config: "Config",
+        title,
+        start_time,
+        headers={},
+        subtitles=[],
     ):
+        self.subs = subtitles
         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"
@@ -120,32 +182,71 @@ class MpvPlayer(object):
         self.current_media_title = ""
 
         mpv_player = mpv.MPV(
+            log_handler=print,
+            loglevel="error",
             config=True,
             input_default_bindings=True,
             input_vo_keyboard=True,
             osc=True,
+            ytdl=True,
         )
-        mpv_player.title = title
 
+        # -- events --
+        @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)
+            try:
+                if not mpv_player.core_shutdown:
+                    if self.subs:
+                        for i, subtitle in enumerate(self.subs):
+                            if i == 0:
+                                flag = "select"
+                            else:
+                                flag = "auto"
+                            mpv_player.sub_add(
+                                subtitle["url"], flag, None, subtitle["language"]
+                            )
+                        self.subs = []
+            except mpv.ShutdownError:
+                pass
+            except Exception:
+                pass
+
+        @mpv_player.property_observer("time-pos")
+        def handle_time_start_update(*args):
+            if len(args) > 1:
+                value = args[1]
+                if value is not None:
+                    self.last_stop_time = format_time(value)
+
+        @mpv_player.property_observer("time-remaining")
+        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")
         def _next_episode():
             url = self.get_episode("next")
             if url:
-                mpv_player.loadfile(url, options=f"title={self.current_media_title}")
+                mpv_player.loadfile(
+                    url,
+                )
                 mpv_player.title = self.current_media_title
 
-        @mpv_player.event_callback("file-loaded")
-        def set_total_time(event, *args):
-            d = mpv_player._get_property("duration")
-            if isinstance(d, float):
-                self.last_total_time = format_time(d)
-
-        @mpv_player.event_callback("shutdown")
-        def set_total_time_on_shutdown(event, *args):
-            d = mpv_player._get_property("duration")
-            if isinstance(d, float):
-                self.last_total_time = format_time(d)
-
         @mpv_player.on_key_press("shift+p")
         def _previous_episode():
             url = self.get_episode("previous")
@@ -166,14 +267,17 @@ class MpvPlayer(object):
         @mpv_player.on_key_press("shift+t")
         def _toggle_translation_type():
             translation_type = "sub" if config.translation_type == "dub" else "dub"
+            mpv_player.show_text("Changing translation type...")
             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":
@@ -190,31 +294,11 @@ class MpvPlayer(object):
                 )
                 mpv_player.title = self.current_media_title
 
-        @mpv_player.property_observer("time-pos")
-        def handle_time_start_update(*args):
-            if len(args) > 1:
-                value = args[1]
-                if value is not None:
-                    self.last_stop_time_secs = value
-                    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:
-                    rem_time = value
-                    if rem_time < 10 and config.auto_next:
-                        url = self.get_episode("next")
-                        if url:
-                            mpv_player.loadfile(
-                                url,
-                            )
-                            mpv_player.title = self.current_media_title
-
+        # -- script messages --
         @mpv_player.message_handler("select-episode")
         def select_episode(episode: bytes | None = None, *args):
             if not episode:
+                mpv_player.show_text("No episode was selected")
                 return
             url = self.get_episode("custom", episode.decode())
             if url:
@@ -223,13 +307,69 @@ class MpvPlayer(object):
                 )
                 mpv_player.title = self.current_media_title
 
-        mpv_player.register_message_handler("select-episode", select_episode)
+        @mpv_player.message_handler("select-server")
+        def select_server(server: bytes | None = None, *args):
+            if not server:
+                mpv_player.show_text("No server was selected")
+                return
+            url = self.get_episode("reload", server=server.decode())
+            if url:
+                mpv_player.loadfile(
+                    url,
+                )
+                mpv_player.title = self.current_media_title
+            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.register_event_callback(set_total_time)
-        mpv_player.register_event_callback(set_total_time_on_shutdown)
         mpv_player.observe_property("time-remaining", handle_time_remaining_update)
+        mpv_player.register_event_callback(set_total_time)
+
+        # --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
+        mpv_player.force_window = config.force_window
+        # mpv_player.cache = "yes"
+        # mpv_player.cache_pause = "no"
+        mpv_player.title = title
+        mpv_headers = ""
+        if headers:
+            for header_name, header_value in headers.items():
+                mpv_headers += f"{header_name}:{header_value},"
+        mpv_player.http_header_fields = mpv_headers
+
+        mpv_player.play(stream_link)
+
+        if not start_time == "0":
+            mpv_player.start = start_time
+
+        mpv_player.wait_for_shutdown()
+        mpv_player.terminate()
 
 
 player = MpvPlayer()

fastanime/cli/utils/print_img.py

@@ -5,20 +5,23 @@ import requests
 
 
 def print_img(url: str):
-    executable = shutil.which("chafa")
-    curl = shutil.which("curl")
-    #   curl -sL "$1" | chafa /dev/stdin
+    """helper funtion to print an image given its url
 
-    if executable is None or curl is None:
-        print("chafa or curl not found")
-        return
+    Args:
+        url: [TODO:description]
+    """
+    if EXECUTABLE := shutil.which("icat"):
+        subprocess.run([EXECUTABLE, url])
+    else:
+        EXECUTABLE = shutil.which("chafa")
 
-    res = requests.get(url)
-    if res.status_code != 200:
-        print("Error fetching image")
-        return
-    img_bytes = res.content
-    if not img_bytes:
-        print("No image found")
-        img_bytes = subprocess.check_output([curl, "-sL", url])
-    subprocess.run([executable, url, "--size=15x15"], input=img_bytes)
+        if EXECUTABLE is None:
+            print("chafanot found")
+            return
+
+        res = requests.get(url)
+        if res.status_code != 200:
+            print("Error fetching image")
+            return
+        img_bytes = res.content
+        subprocess.run([EXECUTABLE, url, "--size=15x15"], input=img_bytes)

fastanime/cli/utils/scripts.py

@@ -0,0 +1,78 @@
+# 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
+# image in the preview window of fzf.
+#
+# Dependencies:
+# - https://github.com/sharkdp/bat
+# - https://github.com/hpjansson/chafa
+# - https://iterm2.com/utilities/imgcat
+fzf-preview(){
+    if [[ $# -ne 1 ]]; then
+    >&2 echo "usage: $0 FILENAME"
+    exit 1
+    fi
+
+    file=${1/#\~\//$HOME/}
+    type=$(file --dereference --mime -- "$file")
+
+    if [[ ! $type =~ image/ ]]; then
+    if [[ $type =~ =binary ]]; then
+        file "$1"
+        exit
+    fi
+
+    # Sometimes bat is installed as batcat.
+    if command -v batcat > /dev/null; then
+        batname="batcat"
+    elif command -v bat > /dev/null; then
+        batname="bat"
+    else
+        cat "$1"
+        exit
+    fi
+
+    ${batname} --style="${BAT_STYLE:-numbers}" --color=always --pager=never -- "$file"
+    exit
+    fi
+
+    dim=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}
+    if [[ $dim = x ]]; then
+    dim=$(stty size < /dev/tty | awk '{print $2 "x" $1}')
+    elif ! [[ $KITTY_WINDOW_ID ]] && (( FZF_PREVIEW_TOP + FZF_PREVIEW_LINES == $(stty size < /dev/tty | awk '{print $1}') )); then
+    # Avoid scrolling issue when the Sixel image touches the bottom of the screen
+    # * https://github.com/junegunn/fzf/issues/2544
+    dim=${FZF_PREVIEW_COLUMNS}x$((FZF_PREVIEW_LINES - 1))
+    fi
+
+# 1. Use kitty icat on kitty terminal
+    if [[ $KITTY_WINDOW_ID ]]; then
+    # 1. 'memory' is the fastest option but if you want the image to be scrollable,
+    #    you have to use 'stream'.
+    #
+    # 2. The last line of the output is the ANSI reset code without newline.
+    #    This confuses fzf and makes it render scroll offset indicator.
+    #    So we remove the last line and append the reset code to its previous line.
+    kitty icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place="$dim@0x0" "$file" | sed '$d' | sed $'$s/$/\e[m/'
+
+# 2. Use chafa with Sixel output
+    elif command -v chafa > /dev/null; then
+    chafa -f sixel -s "$dim" "$file"
+    # Add a new line character so that fzf can display multiple images in the preview window
+    echo
+
+# 3. If chafa is not found but imgcat is available, use it on iTerm2
+    elif command -v imgcat > /dev/null; then
+    # NOTE: We should use https://iterm2.com/utilities/it2check to check if the
+    # user is running iTerm2. But for the sake of simplicity, we just assume
+    # that's the case here.
+    imgcat -W "${dim%%x*}" -H "${dim##*x}" "$file"
+
+# 4. Cannot find any suitable method to preview the image
+    else
+    file "$file"
+    fi
+}
+"""

fastanime/cli/utils/syncplay.py

@@ -0,0 +1,44 @@
+import shutil
+import subprocess
+
+from .tools import exit_app
+
+
+def SyncPlayer(url: str, anime_title=None, headers={}, subtitles=[], *args):
+    # TODO: handle m3u8 multi quality streams
+    #
+    # check for SyncPlay
+    SYNCPLAY_EXECUTABLE = shutil.which("syncplay")
+    if not SYNCPLAY_EXECUTABLE:
+        print("Syncplay not found")
+        exit_app(1)
+        return "0", "0"
+    # start SyncPlayer
+    mpv_args = []
+    if headers:
+        mpv_headers = "--http-header-fields="
+        for header_name, header_value in headers.items():
+            mpv_headers += f"{header_name}:{header_value},"
+        mpv_args.append(mpv_headers)
+    for subtitle in subtitles:
+        mpv_args.append(f"--sub-file={subtitle['url']}")
+    if not anime_title:
+        subprocess.run(
+            [
+                SYNCPLAY_EXECUTABLE,
+                url,
+            ]
+        )
+    else:
+        subprocess.run(
+            [
+                SYNCPLAY_EXECUTABLE,
+                url,
+                "--",
+                f"--force-media-title={anime_title}",
+                *mpv_args,
+            ]
+        )
+
+    # for compatability
+    return "0", "0"

fastanime/cli/utils/tools.py

@@ -1,5 +1,6 @@
-class QueryDict(dict):
-    """dot.notation access to dictionary attributes"""
+# TODO: add typing
+class FastAnimeRuntimeState(dict):
+    """A class that manages fastanime runtime during anilist command runtime"""
 
     def __getattr__(self, attr):
         try:
@@ -13,25 +14,15 @@ class QueryDict(dict):
         self.__setitem__(attr, value)
 
 
-def exit_app(*args):
-    import os
-    import shutil
+def exit_app(exit_code=0, *args):
     import sys
 
+    from rich.console import Console
+
     from ...constants import APP_NAME, ICON_PATH, USER_NAME
 
-    def is_running_in_terminal():
-        try:
-            shutil.get_terminal_size()
-            return (
-                sys.stdin.isatty()
-                and sys.stdout.isatty()
-                and os.getenv("TERM") is not None
-            )
-        except OSError:
-            return False
-
-    if not is_running_in_terminal():
+    console = Console()
+    if not console.is_terminal:
         from plyer import notification
 
         notification.notify(
@@ -41,20 +32,6 @@ def exit_app(*args):
             title="Shutting down",
         )  # pyright:ignore
     else:
-        from rich import print
-
-        print("Have a good day :smile:", USER_NAME)
-    sys.exit(0)
-
-
-def get_formatted_str(string: str, style):
-    from rich.text import Text
-
-    # Create a Text object with desired style
-    text = Text(string, style="bold red")
-
-    # Convert the Text object to an ANSI string
-    ansi_output = text.__rich_console__(None, None)  # pyright:ignore
-
-    # Join the ANSI strings to form the final output
-    "".join(segment.text for segment in ansi_output)
+        console.clear()
+        console.print("Have a good day :smile:", USER_NAME)
+    sys.exit(exit_code)

fastanime/cli/utils/utils.py

@@ -1,12 +1,11 @@
 import logging
+from typing import TYPE_CHECKING
 
 from InquirerPy import inquirer
-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 +19,109 @@ BG_GREEN = "\033[48;2;120;233;12;m"
 GREEN = "\033[38;2;45;24;45;m"
 
 
-def sizeof_fmt(num, suffix="B"):
+def get_requested_quality_or_default_to_first(url, quality):
+    import yt_dlp
+
+    with yt_dlp.YoutubeDL({"quiet": True, "silent": True, "no_warnings": True}) as ydl:
+        m3u8_info = ydl.extract_info(url, False)
+        if not m3u8_info:
+            return
+
+    m3u8_formats = m3u8_info["formats"]
+    quality = int(quality)
+    quality_u = quality - 80
+    quality_l = quality + 80
+    for m3u8_format in m3u8_formats:
+        if m3u8_format["height"] == quality or (
+            m3u8_format["height"] < quality_u and m3u8_format["height"] > quality_l
+        ):
+            return m3u8_format["url"]
+    else:
+        return m3u8_formats[0]["url"]
+
+
+def move_preferred_subtitle_lang_to_top(sub_list, lang_str):
+    """Moves the dictionary with the given ID to the front of the list.
+
+    Args:
+      sub_list: list of subs
+      lang_str: the sub lang pref
+
+    Returns:
+      The modified list.
+    """
+    import re
+
+    for i, d in enumerate(sub_list):
+        if re.search(lang_str, d["language"], re.IGNORECASE):
+            sub_list.insert(0, sub_list.pop(i))
+            break
+    return sub_list
+
+
+def filter_by_quality(quality: str, stream_links: "list[EpisodeStream]", default=True):
+    """Helper function used to filter a list of EpisodeStream objects to one that has a corresponding quality
+
+    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:
+        q = float(quality)
+        Q = float(stream_link["quality"])
+        # some providers have inaccurate/weird/non-standard eg qualities 718 instead of 720
+        if Q <= q + 80 and Q >= q - 80:
+            return stream_link
+    else:
+        if stream_links and default:
+            from rich import print
+
+            try:
+                print("[yellow bold]WARNING Qualities were:[/] ", stream_links)
+                print(
+                    "[cyan bold]Using default of quality:[/] ",
+                    stream_links[0]["quality"],
+                )
+                return stream_links[0]
+            except Exception as e:
+                print(e)
+                return
+
+
+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,11 +132,21 @@ 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()
-    action = inquirer.fuzzy(
+    action = inquirer.fuzzy(  # pyright:ignore
         prompt,
         choices,
         height="100%",
@@ -52,29 +155,3 @@ def fuzzy_inquirer(prompt: str, choices, **kwargs):
         **kwargs,
     ).execute()
     return action
-
-
-def anime_title_percentage_match(
-    possible_user_requested_anime_title: str, title: tuple
-) -> float:
-    """Returns the percentage match between the possible title and user title
-
-    Args:
-        possible_user_requested_anime_title (str): an Animdl search result title
-        title (str): the anime title the user wants
-
-    Returns:
-        int: the percentage match
-    """
-    if normalized_anime_title := anime_normalizer.get(
-        possible_user_requested_anime_title
-    ):
-        possible_user_requested_anime_title = normalized_anime_title
-    for key, value in locals().items():
-        logger.info(f"{key}: {value}")
-    # compares both the romaji and english names and gets highest Score
-    percentage_ratio = max(
-        fuzz.ratio(title[0].lower(), possible_user_requested_anime_title.lower()),
-        fuzz.ratio(title[1].lower(), possible_user_requested_anime_title.lower()),
-    )
-    return percentage_ratio

fastanime/constants.py

@@ -1,17 +1,16 @@
 import os
+import sys
+from pathlib import Path
 from platform import system
 
-from platformdirs import PlatformDirs
+import click
 
-from . import APP_NAME, AUTHOR
+from . import APP_NAME, __version__
 
 PLATFORM = system()
-dirs = PlatformDirs(appname=APP_NAME, appauthor=AUTHOR, ensure_exists=True)
-
 
 # ---- app deps ----
 APP_DIR = os.path.abspath(os.path.dirname(__file__))
-CONFIGS_DIR = os.path.join(APP_DIR, "configs")
 ASSETS_DIR = os.path.join(APP_DIR, "assets")
 
 
@@ -20,21 +19,67 @@ if PLATFORM == "Windows":
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.ico")
 else:
     ICON_PATH = os.path.join(ASSETS_DIR, "logo.png")
+# PREVIEW_IMAGE = os.path.join(ASSETS_DIR, "preview")
+
 
 # ----- user configs and data -----
-APP_DATA_DIR = dirs.user_config_dir
-if not APP_DATA_DIR:
-    APP_DATA_DIR = dirs.user_data_dir
 
+S_PLATFORM = sys.platform
+APP_DATA_DIR = click.get_app_dir(APP_NAME)
+if S_PLATFORM == "win32":
+    # app data
+    # app_data_dir_base = os.getenv("LOCALAPPDATA")
+    # if not app_data_dir_base:
+    #     raise RuntimeError("Could not determine app data dir please report to devs")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, AUTHOR, APP_NAME)
+    #
+    # cache dir
+    APP_CACHE_DIR = os.path.join(APP_DATA_DIR, "cache")
+
+    # videos dir
+    video_dir_base = os.path.join(Path().home(), "Videos")
+    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
+
+elif S_PLATFORM == "darwin":
+    # app data
+    # app_data_dir_base = os.path.expanduser("~/Library/Application Support")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME, __version__)
+    #
+    # cache dir
+    cache_dir_base = os.path.expanduser("~/Library/Caches")
+    APP_CACHE_DIR = os.path.join(cache_dir_base, APP_NAME, __version__)
+
+    # videos dir
+    video_dir_base = os.path.expanduser("~/Movies")
+    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
+else:
+    # # app data
+    # app_data_dir_base = os.environ.get("XDG_CONFIG_HOME", "")
+    # if not app_data_dir_base.strip():
+    #     app_data_dir_base = os.path.expanduser("~/.config")
+    # APP_DATA_DIR = os.path.join(app_data_dir_base, APP_NAME)
+    #
+    # cache dir
+    cache_dir_base = os.environ.get("XDG_CACHE_HOME", "")
+    if not cache_dir_base.strip():
+        cache_dir_base = os.path.expanduser("~/.cache")
+    APP_CACHE_DIR = os.path.join(cache_dir_base, APP_NAME)
+
+    # videos dir
+    video_dir_base = os.environ.get("XDG_VIDEOS_DIR", "")
+    if not video_dir_base.strip():
+        video_dir_base = os.path.expanduser("~/Videos")
+    USER_VIDEOS_DIR = os.path.join(video_dir_base, APP_NAME)
+
+# ensure paths exist
+Path(APP_DATA_DIR).mkdir(parents=True, exist_ok=True)
+Path(APP_CACHE_DIR).mkdir(parents=True, exist_ok=True)
+Path(USER_VIDEOS_DIR).mkdir(parents=True, exist_ok=True)
+
+# useful paths
 USER_DATA_PATH = os.path.join(APP_DATA_DIR, "user_data.json")
 USER_CONFIG_PATH = os.path.join(APP_DATA_DIR, "config.ini")
-NOTIFIER_LOG_FILE_PATH = os.path.join(APP_DATA_DIR, "notifier.log")
-
-# cache dir
-APP_CACHE_DIR = dirs.user_cache_dir
-
-# video dir
-USER_VIDEOS_DIR = os.path.join(dirs.user_videos_dir, APP_NAME)
+LOG_FILE_PATH = os.path.join(APP_DATA_DIR, "fastanime.log")
 
 
 USER_NAME = os.environ.get("USERNAME", "Anime fun")

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(
@@ -307,9 +309,14 @@ class AniListApi:
         status_not_in: list[str] | None = None,
         endDate_greater: int | None = None,
         endDate_lesser: int | None = None,
-        start_greater: int | None = None,
-        start_lesser: int | None = None,
+        startDate_greater: int | None = None,
+        startDate_lesser: int | None = None,
+        startDate: str | None = None,
+        seasonYear: str | None = None,
         page: int | None = None,
+        season: str | None = None,
+        format_in: list[str] | None = None,
+        type="ANIME",
         **kwargs,
     ):
         """
@@ -317,7 +324,7 @@ class AniListApi:
         """
         variables = {}
         for key, val in list(locals().items())[1:]:
-            if val is not None and key not in ["variables"]:
+            if val and key not in ["variables"]:
                 variables[key] = val
         search_results = self.get_data(search_query, variables=variables)
         return search_results
@@ -329,65 +336,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 {
@@ -147,6 +147,11 @@ query ($userId: Int, $status: MediaListStatus) {
           id
         }
         popularity
+            streamingEpisodes{
+        title
+        thumbnail
+    }
+
         favourites
         averageScore
         episodes
@@ -173,6 +178,7 @@ query ($userId: Int, $status: MediaListStatus) {
         status
         description
         mediaListEntry{
+        status
         id
         progress
         }
@@ -220,17 +226,22 @@ $popularity_greater:Int,\
 $popularity_lesser:Int,\
 $averageScore_greater:Int,\
 $averageScore_lesser:Int,\
+$seasonYear:Int,\
 $startDate_greater:FuzzyDateInt,\
 $startDate_lesser:FuzzyDateInt,\
+$startDate:FuzzyDateInt,\
 $endDate_greater:FuzzyDateInt,\
-$endDate_lesser:FuzzyDateInt\
+$endDate_lesser:FuzzyDateInt,\
+$format_in:[MediaFormat],\
+$type:MediaType\
+$season:MediaSeason\
 "
 # FuzzyDateInt = (yyyymmdd)
 # MediaStatus = (FINISHED,RELEASING,NOT_YET_RELEASED,CANCELLED,HIATUS)
 search_query = (
     """
 query($query:String,%s){
-  Page(perPage:30,page:$page){
+  Page(perPage:50,page:$page){
     pageInfo{
       total
       currentPage
@@ -245,6 +256,7 @@ query($query:String,%s){
       tag_not_in:$tag_not_in,
       status_in:$status_in,
       status:$status,
+    startDate:$startDate,
       status_not_in:$status_not_in,
       popularity_greater:$popularity_greater,
       popularity_lesser:$popularity_lesser,
@@ -254,8 +266,11 @@ query($query:String,%s){
       startDate_lesser:$startDate_lesser,
       endDate_greater:$endDate_greater,
       endDate_lesser:$endDate_lesser,
+    format_in:$format_in,
       sort:$sort,
-      type:ANIME
+    season:$season,
+    seasonYear:$seasonYear,
+      type:$type
       )
     {
       id
@@ -274,10 +289,16 @@ query($query:String,%s){
         
       }
         mediaListEntry{
+    status
         id
         progress
         }
       popularity
+        streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       averageScore
       episodes
@@ -316,10 +337,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{
@@ -335,6 +356,11 @@ query{
         id
       }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       averageScore
       genres
@@ -355,6 +381,7 @@ query{
         day
       }
         mediaListEntry{
+        status
         id
         progress
         }
@@ -376,9 +403,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{
@@ -395,10 +422,20 @@ query{
         
       }
         mediaListEntry{
+        status
         id
         progress
         }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
+    streamingEpisodes{
+        title
+        thumbnail
+    }
       favourites
       averageScore
       episodes
@@ -435,9 +472,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{
@@ -454,10 +491,16 @@ query{
         
       }
         mediaListEntry{
+        status
         id
         progress
         }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       episodes
       favourites
       averageScore
@@ -494,9 +537,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{
@@ -513,12 +556,18 @@ query{
         
       }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       averageScore
       description
       episodes
       genres
         mediaListEntry{
+        status
         id
         progress
         }
@@ -553,9 +602,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{
@@ -571,10 +620,16 @@ query{
         id     
       }
         mediaListEntry{
+        status
         id
         progress
         }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       averageScore
       description
@@ -611,9 +666,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{
@@ -629,6 +684,7 @@ query  {
               large
             }
             mediaListEntry{
+            status
                 id
                 progress
             }
@@ -642,6 +698,11 @@ query  {
             genres
             averageScore
             popularity
+                streamingEpisodes{
+        title
+        thumbnail
+    }
+
             favourites
             tags {
               name
@@ -671,9 +732,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 +767,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
@@ -723,6 +784,7 @@ query ($id: Int) {
             large
           }
         mediaListEntry{
+        status
         id
         progress
         }
@@ -735,6 +797,11 @@ query ($id: Int) {
           genres
           averageScore
           popularity
+              streamingEpisodes{
+        title
+        thumbnail
+    }
+
           favourites
           tags {
             name
@@ -763,9 +830,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 +847,7 @@ query ($id: Int) {
 """
 
 upcoming_anime_query = """
-query ($page: Int) {
+query ($page: Int,$type:MediaType) {
   Page(page: $page) {
     pageInfo {
       total
@@ -788,7 +855,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 {
@@ -804,10 +871,16 @@ query ($page: Int) {
         id
       }
               mediaListEntry{
+              status
         id
         progress
         }
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       averageScore
       genres
@@ -854,6 +927,7 @@ query($id:Int){
         english
       }
               mediaListEntry{
+              status
         id
         progress
         }
@@ -923,6 +997,11 @@ query($id:Int){
       countryOfOrigin
       averageScore
       popularity
+          streamingEpisodes{
+        title
+        thumbnail
+    }
+
       favourites
       source
       hashtag

fastanime/libs/anilist/types.py

@@ -136,6 +136,11 @@ class AnilistMediaListProperties(TypedDict):
     hiddenFromStatusLists: bool
 
 
+class StreamingEpisode(TypedDict):
+    title: str
+    thumbnail: str
+
+
 class AnilistBaseMediaDataSchema(TypedDict):
     """
     This a convenience class is used to type the received Anilist data to enhance dev experience
@@ -159,6 +164,7 @@ class AnilistBaseMediaDataSchema(TypedDict):
     status: str
     nextAiringEpisode: AnilistMediaNextAiringEpisode
     season: str
+    streamingEpisodes: list[StreamingEpisode]
     seasonYear: int
     duration: int
     synonyms: list[str]

fastanime/libs/anime_provider/__init__.py

@@ -1,5 +1,11 @@
+from .allanime.constants import SERVERS_AVAILABLE as ALLANIME_SERVERS
+from .animepahe.constants import SERVERS_AVAILABLE as ANIMEPAHESERVERS
+from .aniwatch.constants import SERVERS_AVAILABLE as ANIWATCHSERVERS
+
 anime_sources = {
     "allanime": "api.AllAnimeAPI",
     "animepahe": "api.AnimePaheApi",
     "aniwatch": "api.AniWatchApi",
+    "aniwave": "api.AniWaveApi",
 }
+SERVERS_AVAILABLE = [*ALLANIME_SERVERS, *ANIMEPAHESERVERS, *ANIWATCHSERVERS]

fastanime/libs/anime_provider/allanime/api.py

@@ -10,15 +10,9 @@ from typing import TYPE_CHECKING
 from requests.exceptions import Timeout
 
 from ...anime_provider.base_provider import AnimeProvider
-from ..utils import decode_hex_string
-from .constants import (
-    ALLANIME_API_ENDPOINT,
-    ALLANIME_BASE,
-    ALLANIME_REFERER,
-    USER_AGENT,
-)
+from ..utils import give_random_quality, one_digit_symmetric_xor
+from .constants import ALLANIME_API_ENDPOINT, ALLANIME_BASE, ALLANIME_REFERER
 from .gql_queries import ALLANIME_EPISODES_GQL, ALLANIME_SEARCH_GQL, ALLANIME_SHOW_GQL
-from .normalizer import normalize_anime, normalize_search_results
 
 if TYPE_CHECKING:
     from typing import Iterator
@@ -37,6 +31,9 @@ class AllAnimeAPI(AnimeProvider):
     """
 
     api_endpoint = ALLANIME_API_ENDPOINT
+    HEADERS = {
+        "Referer": ALLANIME_REFERER,
+    }
 
     def _fetch_gql(self, query: str, variables: dict):
         """main abstraction over all requests to the allanime api
@@ -55,7 +52,6 @@ class AllAnimeAPI(AnimeProvider):
                     "variables": json.dumps(variables),
                     "query": query,
                 },
-                headers={"Referer": ALLANIME_REFERER, "User-Agent": USER_AGENT},
                 timeout=10,
             )
             if response.status_code == 200:
@@ -106,7 +102,23 @@ class AllAnimeAPI(AnimeProvider):
         }
         try:
             search_results = self._fetch_gql(ALLANIME_SEARCH_GQL, variables)
-            return normalize_search_results(search_results)  # pyright:ignore
+            page_info = search_results["shows"]["pageInfo"]
+            results = []
+            for result in search_results["shows"]["edges"]:
+                normalized_result = {
+                    "id": result["_id"],
+                    "title": result["name"],
+                    "type": result["__typename"],
+                    "availableEpisodes": result["availableEpisodes"],
+                }
+                results.append(normalized_result)
+
+            normalized_search_results = {
+                "pageInfo": page_info,
+                "results": results,
+            }
+            return normalized_search_results
+
         except Exception as e:
             logger.error(f"FA(AllAnime): {e}")
             return {}
@@ -123,9 +135,19 @@ class AllAnimeAPI(AnimeProvider):
         variables = {"showId": allanime_show_id}
         try:
             anime = self._fetch_gql(ALLANIME_SHOW_GQL, variables)
-            return normalize_anime(anime["show"])
+            id: str = anime["show"]["_id"]
+            title: str = anime["show"]["name"]
+            availableEpisodesDetail = anime["show"]["availableEpisodesDetail"]
+            type = anime.get("__typename")
+            normalized_anime = {
+                "id": id,
+                "title": title,
+                "availableEpisodesDetail": availableEpisodesDetail,
+                "type": type,
+            }
+            return normalized_anime
         except Exception as e:
-            logger.error(f"FA(AllAnime): {e}")
+            logger.error(f"AllAnime(get_anime): {e}")
             return None
 
     def _get_anime_episode(
@@ -180,171 +202,122 @@ class AllAnimeAPI(AnimeProvider):
                     # filter the working streams no need to get all since the others are mostly hsl
                     # TODO: should i just get all the servers and handle the hsl??
                     if embed.get("sourceName", "") not in (
-                        "Sak",
-                        "Kir",
-                        "S-mp4",
-                        "Luf-mp4",
-                        "Default",
+                        # priorities based on death note
+                        "Sak",  #  7
+                        "S-mp4",  # 7.9
+                        "Luf-mp4",  # 7.7
+                        "Default",  # 8.5
+                        "Yt-mp4",  # 7.9
+                        "Kir",  # NA
+                        # "Vid-mp4"  # 4
+                        # "Ok",  # 3.5
+                        # "Ss-Hls",  #  5.5
+                        # "Mp4",  # 4
                     ):
                         continue
                     url = embed.get("sourceUrl")
-
+                    #
                     if not url:
                         continue
                     if url.startswith("--"):
                         url = url[2:]
+                        url = one_digit_symmetric_xor(56, url)
+
+                    if "tools.fast4speed.rsvp" in url:
+                        yield {
+                            "server": "Yt",
+                            "episode_title": f'{anime["title"]}; Episode {episode_number}',
+                            "headers": {"Referer": f"https://{ALLANIME_BASE}/"},
+                            "subtitles": [],
+                            "links": [
+                                {
+                                    "link": url,
+                                    "quality": "1080",
+                                }
+                            ],
+                        }  # pyright:ignore
+                        continue
 
                     # get the stream url for an episode of the defined source names
-                    parsed_url = decode_hex_string(url)
-                    embed_url = f"https://{ALLANIME_BASE}{parsed_url.replace('clock', 'clock.json')}"
+                    embed_url = (
+                        f"https://{ALLANIME_BASE}{url.replace('clock', 'clock.json')}"
+                    )
                     resp = self.session.get(
                         embed_url,
-                        headers={
-                            "Referer": ALLANIME_REFERER,
-                            "User-Agent": USER_AGENT,
-                        },
                         timeout=10,
                     )
+
                     if resp.status_code == 200:
                         match embed["sourceName"]:
                             case "Luf-mp4":
                                 logger.debug("allanime:Found streams from gogoanime")
                                 yield {
                                     "server": "gogoanime",
+                                    "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         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")
                                 yield {
                                     "server": "wetransfer",
+                                    "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         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")
                                 yield {
                                     "server": "sharepoint",
+                                    "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         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")
                                 yield {
                                     "server": "dropbox",
+                                    "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         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")
                                 yield {
                                     "server": "wixmp",
+                                    "headers": {},
+                                    "subtitles": [],
                                     "episode_title": (
                                         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(
                         "Timeout has been exceeded this could mean allanime is down or you have lost internet connection"
                     )
-                    return []
+
                 except Exception as e:
                     logger.error(f"FA(Allanime): {e}")
-                    return []
+
         except Exception as e:
             logger.error(f"FA(Allanime): {e}")
             return []
-
-
-if __name__ == "__main__":
-    anime_provider = AllAnimeAPI()
-    # lets see if it works :)
-    import subprocess
-    import sys
-
-    from InquirerPy import inquirer, validator
-
-    anime = input("Enter the anime name: ")
-    translation = input("Enter the translation type: ")
-
-    search_results = anime_provider.search_for_anime(
-        anime, translation_type=translation.strip()
-    )
-
-    if not search_results:
-        raise Exception("No results found")
-
-    search_results = search_results["results"]
-    options = {show["title"]: show for show in search_results}
-    anime = inquirer.fuzzy(
-        "Enter the anime title",
-        list(options.keys()),
-        validate=validator.EmptyInputValidator(),
-    ).execute()
-    if anime is None:
-        print("No anime was selected")
-        sys.exit(1)
-
-    anime_result = options[anime]
-    anime_data = anime_provider.get_anime(anime_result["id"])
-    if not anime_data:
-        raise Exception("Anime not found")
-    availableEpisodesDetail = anime_data["availableEpisodesDetail"]
-    if not availableEpisodesDetail.get(translation.strip()):
-        raise Exception("No episodes found")
-
-    stream_link = True
-    while stream_link != "quit":
-        print("select episode")
-        episode = inquirer.fuzzy(
-            "Choose an episode",
-            availableEpisodesDetail[translation.strip()],
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if episode is None:
-            print("No episode was selected")
-            sys.exit(1)
-
-        if not anime_data:
-            print("Sth went wrong")
-            break
-        episode_streams_ = anime_provider.get_episode_streams(
-            anime_data, episode, translation.strip()
-        )
-        if episode_streams_ is None:
-            raise Exception("Episode not found")
-
-        episode_streams = list(episode_streams_)
-        stream_links = []
-        for server in episode_streams:
-            stream_links.extend([link["link"] for link in server["links"]])
-        stream_links.append("back")
-        stream_link = inquirer.fuzzy(
-            "Choose a link to stream",
-            stream_links,
-            validate=validator.EmptyInputValidator(),
-        ).execute()
-        if stream_link == "quit":
-            print("Have a nice day")
-            sys.exit()
-        if not stream_link:
-            raise Exception("No stream was selected")
-
-        title = episode_streams[0].get(
-            "episode_title", "%s: Episode %s" % (anime_data["title"], episode)
-        )
-        subprocess.run(["mpv", f"--title={title}", stream_link])

fastanime/libs/anime_provider/allanime/constants.py

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

fastanime/libs/anime_provider/allanime/normalizer.py

@@ -1,40 +0,0 @@
-from ..types import Anime, EpisodesDetail, SearchResults
-from .types import AllAnimeEpisode, AllAnimeSearchResults, AllAnimeShow
-
-
-def normalize_search_results(search_results: AllAnimeSearchResults) -> SearchResults:
-    page_info = search_results["shows"]["pageInfo"]
-    results = []
-    for result in search_results["shows"]["edges"]:
-        normalized_result = {
-            "id": result["_id"],
-            "title": result["name"],
-            "type": result["__typename"],
-            "availableEpisodes": result["availableEpisodes"],
-        }
-        results.append(normalized_result)
-
-    normalized_search_results: SearchResults = {
-        "pageInfo": page_info,
-        "results": results,
-    }
-
-    return normalized_search_results
-
-
-def normalize_anime(anime: AllAnimeShow) -> Anime:
-    id: str = anime["_id"]
-    title: str = anime["name"]
-    availableEpisodesDetail: EpisodesDetail = anime["availableEpisodesDetail"]
-    type = anime.get("__typename")
-    normalized_anime: Anime = {
-        "id": id,
-        "title": title,
-        "availableEpisodesDetail": availableEpisodesDetail,
-        "type": type,
-    }
-    return normalized_anime
-
-
-def normalize_episode(episode: AllAnimeEpisode):
-    pass

fastanime/libs/anime_provider/animepahe/api.py

@@ -1,63 +1,240 @@
-import requests
+import logging
+import random
+import re
+import time
+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_elements_html_by_class,
+)
+
+from ..base_provider import AnimeProvider
+from .constants import (
+    ANIMEPAHE_BASE,
+    ANIMEPAHE_ENDPOINT,
+    REQUEST_HEADERS,
+    SERVER_HEADERS,
+)
+from .utils import process_animepahe_embed_page
+
+if TYPE_CHECKING:
+    from ..types import Anime
+    from .types import AnimePaheAnimePage, AnimePaheSearchPage, AnimeSearchResult
+JUICY_STREAM_REGEX = re.compile(r"source='(.*)';")
+logger = logging.getLogger(__name__)
+
+KWIK_RE = re.compile(r"Player\|(.+?)'")
 
 
 # TODO: hack this to completion
-class AnimePaheApi:
-    def search_for_anime(self, user_query, *args):
+class AnimePaheApi(AnimeProvider):
+    search_page: "AnimePaheSearchPage"
+    anime: "AnimePaheAnimePage"
+    HEADERS = REQUEST_HEADERS
+
+    def search_for_anime(self, user_query: str, *args):
         try:
             url = f"{ANIMEPAHE_ENDPOINT}m=search&q={user_query}"
-            headers = {**REQUEST_HEADERS}
-            response = requests.get(url, headers=headers)
+            response = self.session.get(
+                url,
+            )
             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,
-            },
-        }
+        page = 1
+        try:
+            anime_result: "AnimeSearchResult" = [
+                anime
+                for anime in self.search_page["data"]
+                if anime["session"] == session_id
+            ][0]
+            data: "AnimePaheAnimePage" = {}  # pyright:ignore
 
-    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()
+            url = f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page={page}"
+
+            def _pages_loader(
+                url,
+                page,
+            ):
+                response = self.session.get(
+                    url,
+                )
+                if response.status_code == 200:
+                    if not data:
+                        data.update(response.json())
+                    else:
+                        if ep_data := response.json().get("data"):
+                            data["data"].extend(ep_data)
+                    if response.json()["next_page_url"]:
+                        # TODO: Refine this
+                        time.sleep(
+                            random.choice(
+                                [
+                                    0.25,
+                                    0.1,
+                                    0.5,
+                                    0.75,
+                                    1,
+                                ]
+                            )
+                        )
+                        page += 1
+                        url = f"{ANIMEPAHE_ENDPOINT}m=release&id={session_id}&sort=episode_asc&page={page}"
+                        _pages_loader(
+                            url,
+                            page,
+                        )
+
+            _pages_loader(
+                url,
+                page,
+            )
+
+            if not data:
+                return {}
+            self.anime = data  # pyright:ignore
+            episodes = list(map(str, [episode["episode"] for episode in data["data"]]))
+            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": f"{episode['title'] or 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
+    ):
+        try:
+            # 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"
+                )
+                return []
+            episode = episode[0]
+
+            anime_id = anime["id"]
+            # fetch the episode page
+            url = f"{ANIMEPAHE_BASE}/play/{anime_id}/{episode['session']}"
+            response = self.session.get(url)
+            # get the element containing links to juicy streams
+            c = get_element_by_id("resolutionMenu", response.text)
+            resolutionMenuItems = get_elements_html_by_class("dropdown-item", c)
+            # 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 = (
+                f"{episode['title'] or anime['title']}; Episode {episode['episode']}"
+            )
+            # get all links
+            streams = {
+                "server": "kwik",
+                "links": [],
+                "episode_title": episode_title,
+                "subtitles": [],
+                "headers": {},
+            }
+            for res_dict in res_dicts:
+                # 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"
+                    )
+                    return []
+                # get embed page
+                embed_response = self.session.get(
+                    embed_url, headers={"User-Agent": self.USER_AGENT, **SERVER_HEADERS}
+                )
+                if not response.status_code == 200:
+                    continue
+                embed_page = embed_response.text
+
+                decoded_js = process_animepahe_embed_page(embed_page)
+                if not decoded_js:
+                    logger.error("Animepahe: failed to decode embed page")
+                    return
+                juicy_stream = JUICY_STREAM_REGEX.search(decoded_js)
+                if not juicy_stream:
+                    logger.error("Animepahe: failed to find juicy stream")
+                    return
+                juicy_stream = juicy_stream.group(1)
+                # add the link
+                streams["links"].append(
+                    {
+                        "quality": res_dict["data-resolution"],
+                        "translation_type": data_audio,
+                        "link": juicy_stream,
+                    }
+                )
+            yield streams
+        except Exception as e:
+            logger.error(f"Animepahe: {e}")

fastanime/libs/anime_provider/animepahe/constants.py

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

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/animepahe/utils.py

@@ -0,0 +1,81 @@
+# from ..utils import int2base
+import re
+
+from yt_dlp.utils import encode_base_n, get_element_text_and_html_by_tag
+
+
+def animepahe_key_creator(c: int, a: int):
+    if c < a:
+        val_a = ""
+    else:
+        val_a = animepahe_key_creator(int(c / a), a)
+    c = c % a
+    if c > 35:
+        val_b = chr(c + 29)
+    else:
+        val_b = encode_base_n(c, 36)
+    return val_a + val_b
+
+
+def animepahe_embed_decoder(
+    encoded_js_p: str,
+    base_a: int,
+    no_of_keys_c: int,
+    key_values_k: list,
+    decode_mapper_d: dict = {},
+):
+    for i in range(no_of_keys_c):
+        key = animepahe_key_creator(i, base_a)
+        val = key_values_k[i] or key
+        decode_mapper_d[key] = val
+    return re.sub(
+        r"\b\w+\b", lambda match: decode_mapper_d[match.group(0)], encoded_js_p
+    )
+
+
+PARAMETERS_REGEX = re.compile(r"eval\(function\(p,a,c,k,e,d\)\{.*\}\((.*?)\)\)$")
+ENCODE_JS_REGEX = re.compile(r"'(.*?);',(\d+),(\d+),'(.*)'\.split")
+
+
+def process_animepahe_embed_page(embed_page: str):
+    encoded_js_string = ""
+    embed_page_content = embed_page
+    for _ in range(8):
+        text, html = get_element_text_and_html_by_tag("script", embed_page_content)
+        if not text:
+            embed_page_content = re.sub(html, "", embed_page_content)
+            continue
+        encoded_js_string = text.strip()
+        break
+    if not encoded_js_string:
+        return
+    obsfucated_js_parameter_match = PARAMETERS_REGEX.search(encoded_js_string)
+    if not obsfucated_js_parameter_match:
+        return
+    parameter_string = obsfucated_js_parameter_match.group(1)
+    encoded_js_parameter_string = ENCODE_JS_REGEX.search(parameter_string)
+    if not encoded_js_parameter_string:
+        return
+    p: str = encoded_js_parameter_string.group(1)
+    a: int = int(encoded_js_parameter_string.group(2))
+    c: int = int(encoded_js_parameter_string.group(3))
+    k: list = encoded_js_parameter_string.group(4).split("|")
+    return animepahe_embed_decoder(p, a, c, k).replace("\\", "")
+
+
+if __name__ == "__main__":
+    data = """<script>eval(function(p,a,c,k,e,d){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--){d[e(c)]=k[c]||e(c)}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('f $7={H:a(2){4 B(9.7.h(y z("(?:(?:^|.*;)\\\\s*"+d(2).h(/[\\-\\.\\+\\*]/g,"\\\\$&")+"\\\\s*\\\\=\\\\s*([^;]*).*$)|^.*$"),"$1"))||G},E:a(2,q,3,6,5,t){k(!2||/^(?:8|r\\-v|o|m|p)$/i.D(2)){4 w}f b="";k(3){F(3.J){j K:b=3===P?"; 8=O, I N Q M:u:u A":"; r-v="+3;n;j L:b="; 8="+3;n;j S:b="; 8="+3.Z();n}}9.7=d(2)+"="+d(q)+b+(5?"; m="+5:"")+(6?"; o="+6:"")+(t?"; p":"");4 x},Y:a(2,6,5){k(!2||!11.C(2)){4 w}9.7=d(2)+"=; 8=12, R 10 W l:l:l A"+(5?"; m="+5:"")+(6?"; o="+6:"");4 x},C:a(2){4(y z("(?:^|;\\\\s*)"+d(2).h(/[\\-\\.\\+\\*]/g,"\\\\$&")+"\\\\s*\\\\=")).D(9.7)},X:a(){f c=9.7.h(/((?:^|\\s*;)[^\\=]+)(?=;|$)|^\\s*|\\s*(?:\\=[^;]*)?(?:\\1|$)/g,"").T(/\\s*(?:\\=[^;]*)?;\\s*/);U(f e=0;e<c.V;e++){c[e]=B(c[e])}4 c}};',62,65,'||sKey|vEnd|return|sDomain|sPath|cookie|expires|document|function|sExpires|aKeys|encodeURIComponent|nIdx|var||replace||case|if|00|domain|break|path|secure|sValue|max||bSecure|59|age|false|true|new|RegExp|GMT|decodeURIComponent|hasItem|test|setItem|switch|null|getItem|31|constructor|Number|String|23|Dec|Fri|Infinity|9999|01|Date|split|for|length|1970|keys|removeItem|toUTCString|Jan|this|Thu'.split('|'),0,{}));eval(function(p,a,c,k,e,d){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--){d[e(c)]=k[c]||e(c)}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('h o=\'1D://1C-E.1B.1A.1z/1y/E/1x/1w/1v.1u\';h d=s.r(\'d\');h 0=B 1t(d,{\'1s\':{\'1r\':i},\'1q\':\'16:9\',\'D\':1,\'1p\':5,\'1o\':{\'1n\':\'1m\'},1l:[\'7-1k\',\'7\',\'1j\',\'1i-1h\',\'1g\',\'1f-1e\',\'1d\',\'D\',\'1c\',\'1b\',\'1a\',\'19\',\'C\',\'18\'],\'C\':{\'17\':i}});8(!A.15()){d.14=o}x{j z={13:12,11:10,Z:Y,X:i,W:i};h c=B A(z);c.V(o);c.U(d);g.c=c}0.3("T",6=>{g.S.R.Q("P")});0.O=1;k v(b,n,m){8(b.y){b.y(n,m,N)}x 8(b.w){b.w(\'3\'+n,m)}}j 4=k(l){g.M.L(l,\'*\')};v(g,\'l\',k(e){j a=e.a;8(a===\'7\')0.7();8(a===\'f\')0.f();8(a===\'u\')0.u()});0.3(\'t\',6=>{4(\'t\')});0.3(\'7\',6=>{4(\'7\')});0.3(\'f\',6=>{4(\'f\')});0.3(\'K\',6=>{4(0.q);s.r(\'.J-I\').H=G(0.q.F(2))});0.3(\'p\',6=>{4(\'p\')});',62,102,'player|||on|sendMessage||event|play|if||data|element|hls|video||pause|window|const|true|var|function|message|eventHandler|eventName|source|ended|currentTime|querySelector|document|ready|stop|bindEvent|attachEvent|else|addEventListener|config|Hls|new|fullscreen|volume|01|toFixed|String|innerHTML|timestamp|ss|timeupdate|postMessage|parent|false|speed|landscape|lock|orientation|screen|enterfullscreen|attachMedia|loadSource|lowLatencyMode|enableWorker|Infinity|backBufferLength|600|maxMaxBufferLength|180|maxBufferLength|src|isSupported||iosNative|capture|airplay|pip|settings|captions|mute|time|current|progress|forward|fast|rewind|large|controls|kwik|key|storage|seekTime|ratio|global|keyboard|Plyr|m3u8|uwu|b92a392054c041a3f9c6eecabeb0e127183f44e547828447b10bca8d77523e6f|03|stream|org|nextcdn|files|eu|https'.split('|'),0,{}))"""
+    a = 62
+    c = 102
+    k = "player|||on|sendMessage||event|play|if||data|element|hls|video||pause|window|const|true|var|function|message|eventHandler|eventName|source|ended|currentTime|querySelector|document|ready|stop|bindEvent|attachEvent|else|addEventListener|config|Hls|new|fullscreen|volume|toFixed|String|innerHTML|timestamp|ss|timeupdate|postMessage|parent|false|speed|landscape|lock|orientation|screen|enterfullscreen|attachMedia|loadSource|lowLatencyMode|enableWorker|Infinity|backBufferLength|600|maxMaxBufferLength||180|maxBufferLength|src|isSupported||iosNative|capture|airplay|pip|settings|captions|mute|time|current|progress|forward|fast|rewind|large|controls|kwik|key|storage|seekTime|ratio|global|keyboard|Plyr|m3u8|uwu|cda74eaebce25a12f5e548f7c220bb5dc245700b0280bdb45ff98b2fe4803d2b|06|stream|org|nextcdn|files|eu|https".split(
+        "|"
+    )
+
+    p = "h o='1D://1C-11.1B.1A.1z/1y/11/1x/1w/1v.1u';h d=s.r('d');h 0=B 1t(d,{'1s':{'1r':i},'1q':'16:9','D':1,'1p':5,'1o':{'1n':'1m'},1l:['7-1k','7','1j','1i-1h','1g','1f-1e','1d','D','1c','1b','1a','19','C','18'],'C':{'17':i}});8(!A.15()){d.14=o}x{j z={13:12,10:Z,Y:X,W:i,V:i};h c=B A(z);c.U(o);c.T(d);g.c=c}0.3(\"S\",6=>{g.R.Q.P(\"O\")});0.N=1;k v(b,n,m){8(b.y){b.y(n,m,M)}x 8(b.w){b.w('3'+n,m)}}j 4=k(l){g.L.K(l,'*')};v(g,'l',k(e){j a=e.a;8(a==='7')0.7();8(a==='f')0.f();8(a==='u')0.u()});0.3('t',6=>{4('t')});0.3('7',6=>{4('7')});0.3('f',6=>{4('f')});0.3('J',6=>{4(0.q);s.r('.I-H').G=F(0.q.E(2))});0.3('p',6=>{4('p')});"
+    result = animepahe_embed_decoder(
+        p,
+        a,
+        c,
+        k,
+    )
+    print(result)  # Output: j player = B A();

fastanime/libs/anime_provider/aniwatch/api.py

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

fastanime/libs/anime_provider/aniwatch/constants.py

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

fastanime/libs/anime_provider/aniwatch/types.py

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

fastanime/libs/anime_provider/aniwave/api.py

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

fastanime/libs/anime_provider/aniwave/constants.py

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

fastanime/libs/anime_provider/base_provider.py

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

fastanime/libs/anime_provider/common.py

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

fastanime/libs/anime_provider/mini_anilist.py

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

fastanime/libs/anime_provider/types.py

@@ -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,57 @@ 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 AnimeEpisodeInfo(TypedDict):
+    id: str
+    title: str
+    episode: str
+    poster: str | None
+    duration: str | None
+    translation_type: str | None
 
 
 class Anime(TypedDict):
     id: str
     title: str
-    availableEpisodesDetail: EpisodesDetail
+    availableEpisodesDetail: AnimeEpisodeDetails
     type: str | None
+    episodesInfo: list[AnimeEpisodeInfo] | 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
+    quality: Literal["360", "720", "1080", "unknown"]
+    translation_type: Literal["dub", "sub"]
+
+
+class Subtitle(TypedDict):
+    url: str
+    language: str
 
 
 class Server(TypedDict):
+    headers: dict
+    subtitles: list[Subtitle]
+    audio: list
     server: str
-    episode_title: str | None
-    links: list
+    episode_title: str
+    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,23 @@ hex_to_char = {
 }
 
 
+def give_random_quality(links):
+    qualities = cycle(["1080", "720", "480", "360"])
+
+    return [
+        {**episode_stream, "quality": quality}
+        for episode_stream, quality in zip(links, qualities)
+    ]
+
+
+def one_digit_symmetric_xor(password: int, target: str):
+    def genexp():
+        for segment in bytearray.fromhex(target):
+            yield segment ^ password
+
+    return bytes(genexp()).decode("utf-8")
+
+
 def decode_hex_string(hex_string):
     """some of the sources encrypt the urls into hex codes this function decrypts the urls
 

fastanime/libs/common/mini_anilist.py

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

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"
@@ -208,13 +194,13 @@ cffi = ">=1.0.0"
 
 [[package]]
 name = "cachetools"
-version = "5.4.0"
+version = "5.5.0"
 description = "Extensible memoizing collections and decorators"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "cachetools-5.4.0-py3-none-any.whl", hash = "sha256:3ae3b49a3d5e28a77a0be2b37dbcb89005058959cb2323858c2657c4a8cab474"},
-    {file = "cachetools-5.4.0.tar.gz", hash = "sha256:b8adc2e7c07f105ced7bc56dbb6dfbe7c4a00acce20e2227b3f355be89bc6827"},
+    {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"},
+    {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"},
 ]
 
 [[package]]
@@ -859,13 +845,13 @@ testing = ["covdefaults (>=2.3)", "pytest (>=8.2.2)", "pytest-cov (>=5)", "pytes
 
 [[package]]
 name = "pyright"
-version = "1.1.375"
+version = "1.1.377"
 description = "Command line wrapper for pyright"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "pyright-1.1.375-py3-none-any.whl", hash = "sha256:4c5e27eddeaee8b41cc3120736a1dda6ae120edf8523bb2446b6073a52f286e3"},
-    {file = "pyright-1.1.375.tar.gz", hash = "sha256:7765557b0d6782b2fadabff455da2014476404c9e9214f49977a4e49dec19a0f"},
+    {file = "pyright-1.1.377-py3-none-any.whl", hash = "sha256:af0dd2b6b636c383a6569a083f8c5a8748ae4dcde5df7914b3f3f267e14dd162"},
+    {file = "pyright-1.1.377.tar.gz", hash = "sha256:aabc30fedce0ded34baa0c49b24f10e68f4bfc8f68ae7f3d175c4b0f256b4fcf"},
 ]
 
 [package.dependencies]
@@ -875,20 +861,6 @@ nodeenv = ">=1.6.0"
 all = ["twine (>=3.4.1)"]
 dev = ["twine (>=3.4.1)"]
 
-[[package]]
-name = "pyshortcuts"
-version = "1.9.0"
-description = "Create desktop and Start Menu shortcuts for python scripts"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pyshortcuts-1.9.0-py3-none-any.whl", hash = "sha256:54d12ed8cd29bf83ac15153ce882a77072f2032b5f979474c519a2bac5af849d"},
-    {file = "pyshortcuts-1.9.0.tar.gz", hash = "sha256:016e89111337f74ce1ba3f4b79b295a643bc70b3e63ce4600247aa4bafa06877"},
-]
-
-[package.dependencies]
-pywin32 = {version = "*", markers = "platform_system == \"Windows\""}
-
 [[package]]
 name = "pytest"
 version = "8.3.2"
@@ -911,43 +883,6 @@ tomli = {version = ">=1", markers = "python_version < \"3.11\""}
 [package.extras]
 dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
-[[package]]
-name = "python-dotenv"
-version = "1.0.1"
-description = "Read key-value pairs from a .env file and set them as environment variables"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"},
-    {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"},
-]
-
-[package.extras]
-cli = ["click (>=5.0)"]
-
-[[package]]
-name = "pywin32"
-version = "306"
-description = "Python for Window Extensions"
-optional = false
-python-versions = "*"
-files = [
-    {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"},
-    {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"},
-    {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"},
-    {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"},
-    {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"},
-    {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"},
-    {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"},
-    {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"},
-    {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"},
-    {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"},
-    {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"},
-    {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"},
-    {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"},
-    {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.2"
@@ -1222,13 +1157,13 @@ files = [
 
 [[package]]
 name = "tox"
-version = "4.17.0"
+version = "4.18.0"
 description = "tox is a generic virtualenv management and test command line tool"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "tox-4.17.0-py3-none-any.whl", hash = "sha256:82ef41e7e54182e2143daf0b2920d9030c2e1c4291e12091ebad66860c7be7a4"},
-    {file = "tox-4.17.0.tar.gz", hash = "sha256:b1e2e1dfbfdc174d9be95ae78ec2c4d2cf4800d4c15571deddb197a2c90d2de6"},
+    {file = "tox-4.18.0-py3-none-any.whl", hash = "sha256:0a457400cf70615dc0627eb70d293e80cd95d8ce174bb40ac011011f0c03a249"},
+    {file = "tox-4.18.0.tar.gz", hash = "sha256:5dfa1cab9f146becd6e351333a82f9e0ade374451630ba65ee54584624c27b58"},
 ]
 
 [package.dependencies]
@@ -1308,83 +1243,97 @@ files = [
 
 [[package]]
 name = "websockets"
-version = "12.0"
+version = "13.0"
 description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "websockets-12.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d554236b2a2006e0ce16315c16eaa0d628dab009c33b63ea03f41c6107958374"},
-    {file = "websockets-12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2d225bb6886591b1746b17c0573e29804619c8f755b5598d875bb4235ea639be"},
-    {file = "websockets-12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eb809e816916a3b210bed3c82fb88eaf16e8afcf9c115ebb2bacede1797d2547"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c588f6abc13f78a67044c6b1273a99e1cf31038ad51815b3b016ce699f0d75c2"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5aa9348186d79a5f232115ed3fa9020eab66d6c3437d72f9d2c8ac0c6858c558"},
-    {file = "websockets-12.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6350b14a40c95ddd53e775dbdbbbc59b124a5c8ecd6fbb09c2e52029f7a9f480"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:70ec754cc2a769bcd218ed8d7209055667b30860ffecb8633a834dde27d6307c"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6e96f5ed1b83a8ddb07909b45bd94833b0710f738115751cdaa9da1fb0cb66e8"},
-    {file = "websockets-12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4d87be612cbef86f994178d5186add3d94e9f31cc3cb499a0482b866ec477603"},
-    {file = "websockets-12.0-cp310-cp310-win32.whl", hash = "sha256:befe90632d66caaf72e8b2ed4d7f02b348913813c8b0a32fae1cc5fe3730902f"},
-    {file = "websockets-12.0-cp310-cp310-win_amd64.whl", hash = "sha256:363f57ca8bc8576195d0540c648aa58ac18cf85b76ad5202b9f976918f4219cf"},
-    {file = "websockets-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5d873c7de42dea355d73f170be0f23788cf3fa9f7bed718fd2830eefedce01b4"},
-    {file = "websockets-12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3f61726cae9f65b872502ff3c1496abc93ffbe31b278455c418492016e2afc8f"},
-    {file = "websockets-12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed2fcf7a07334c77fc8a230755c2209223a7cc44fc27597729b8ef5425aa61a3"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e332c210b14b57904869ca9f9bf4ca32f5427a03eeb625da9b616c85a3a506c"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5693ef74233122f8ebab026817b1b37fe25c411ecfca084b29bc7d6efc548f45"},
-    {file = "websockets-12.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e9e7db18b4539a29cc5ad8c8b252738a30e2b13f033c2d6e9d0549b45841c04"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6e2df67b8014767d0f785baa98393725739287684b9f8d8a1001eb2839031447"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bea88d71630c5900690fcb03161ab18f8f244805c59e2e0dc4ffadae0a7ee0ca"},
-    {file = "websockets-12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dff6cdf35e31d1315790149fee351f9e52978130cef6c87c4b6c9b3baf78bc53"},
-    {file = "websockets-12.0-cp311-cp311-win32.whl", hash = "sha256:3e3aa8c468af01d70332a382350ee95f6986db479ce7af14d5e81ec52aa2b402"},
-    {file = "websockets-12.0-cp311-cp311-win_amd64.whl", hash = "sha256:25eb766c8ad27da0f79420b2af4b85d29914ba0edf69f547cc4f06ca6f1d403b"},
-    {file = "websockets-12.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0e6e2711d5a8e6e482cacb927a49a3d432345dfe7dea8ace7b5790df5932e4df"},
-    {file = "websockets-12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dbcf72a37f0b3316e993e13ecf32f10c0e1259c28ffd0a85cee26e8549595fbc"},
-    {file = "websockets-12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12743ab88ab2af1d17dd4acb4645677cb7063ef4db93abffbf164218a5d54c6b"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b645f491f3c48d3f8a00d1fce07445fab7347fec54a3e65f0725d730d5b99cb"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9893d1aa45a7f8b3bc4510f6ccf8db8c3b62120917af15e3de247f0780294b92"},
-    {file = "websockets-12.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f38a7b376117ef7aff996e737583172bdf535932c9ca021746573bce40165ed"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f764ba54e33daf20e167915edc443b6f88956f37fb606449b4a5b10ba42235a5"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:1e4b3f8ea6a9cfa8be8484c9221ec0257508e3a1ec43c36acdefb2a9c3b00aa2"},
-    {file = "websockets-12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9fdf06fd06c32205a07e47328ab49c40fc1407cdec801d698a7c41167ea45113"},
-    {file = "websockets-12.0-cp312-cp312-win32.whl", hash = "sha256:baa386875b70cbd81798fa9f71be689c1bf484f65fd6fb08d051a0ee4e79924d"},
-    {file = "websockets-12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ae0a5da8f35a5be197f328d4727dbcfafa53d1824fac3d96cdd3a642fe09394f"},
-    {file = "websockets-12.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5f6ffe2c6598f7f7207eef9a1228b6f5c818f9f4d53ee920aacd35cec8110438"},
-    {file = "websockets-12.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9edf3fc590cc2ec20dc9d7a45108b5bbaf21c0d89f9fd3fd1685e223771dc0b2"},
-    {file = "websockets-12.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8572132c7be52632201a35f5e08348137f658e5ffd21f51f94572ca6c05ea81d"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:604428d1b87edbf02b233e2c207d7d528460fa978f9e391bd8aaf9c8311de137"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a9d160fd080c6285e202327aba140fc9a0d910b09e423afff4ae5cbbf1c7205"},
-    {file = "websockets-12.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87b4aafed34653e465eb77b7c93ef058516cb5acf3eb21e42f33928616172def"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b2ee7288b85959797970114deae81ab41b731f19ebcd3bd499ae9ca0e3f1d2c8"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7fa3d25e81bfe6a89718e9791128398a50dec6d57faf23770787ff441d851967"},
-    {file = "websockets-12.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a571f035a47212288e3b3519944f6bf4ac7bc7553243e41eac50dd48552b6df7"},
-    {file = "websockets-12.0-cp38-cp38-win32.whl", hash = "sha256:3c6cc1360c10c17463aadd29dd3af332d4a1adaa8796f6b0e9f9df1fdb0bad62"},
-    {file = "websockets-12.0-cp38-cp38-win_amd64.whl", hash = "sha256:1bf386089178ea69d720f8db6199a0504a406209a0fc23e603b27b300fdd6892"},
-    {file = "websockets-12.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ab3d732ad50a4fbd04a4490ef08acd0517b6ae6b77eb967251f4c263011a990d"},
-    {file = "websockets-12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1d9697f3337a89691e3bd8dc56dea45a6f6d975f92e7d5f773bc715c15dde28"},
-    {file = "websockets-12.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1df2fbd2c8a98d38a66f5238484405b8d1d16f929bb7a33ed73e4801222a6f53"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23509452b3bc38e3a057382c2e941d5ac2e01e251acce7adc74011d7d8de434c"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e5fc14ec6ea568200ea4ef46545073da81900a2b67b3e666f04adf53ad452ec"},
-    {file = "websockets-12.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46e71dbbd12850224243f5d2aeec90f0aaa0f2dde5aeeb8fc8df21e04d99eff9"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b81f90dcc6c85a9b7f29873beb56c94c85d6f0dac2ea8b60d995bd18bf3e2aae"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:a02413bc474feda2849c59ed2dfb2cddb4cd3d2f03a2fedec51d6e959d9b608b"},
-    {file = "websockets-12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bbe6013f9f791944ed31ca08b077e26249309639313fff132bfbf3ba105673b9"},
-    {file = "websockets-12.0-cp39-cp39-win32.whl", hash = "sha256:cbe83a6bbdf207ff0541de01e11904827540aa069293696dd528a6640bd6a5f6"},
-    {file = "websockets-12.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc4e7fa5414512b481a2483775a8e8be7803a35b30ca805afa4998a84f9fd9e8"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:248d8e2446e13c1d4326e0a6a4e9629cb13a11195051a73acf414812700badbd"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f44069528d45a933997a6fef143030d8ca8042f0dfaad753e2906398290e2870"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4e37d36f0d19f0a4413d3e18c0d03d0c268ada2061868c1e6f5ab1a6d575077"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d829f975fc2e527a3ef2f9c8f25e553eb7bc779c6665e8e1d52aa22800bb38b"},
-    {file = "websockets-12.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2c71bd45a777433dd9113847af751aae36e448bc6b8c361a566cb043eda6ec30"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0bee75f400895aef54157b36ed6d3b308fcab62e5260703add87f44cee9c82a6"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:423fc1ed29f7512fceb727e2d2aecb952c46aa34895e9ed96071821309951123"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27a5e9964ef509016759f2ef3f2c1e13f403725a5e6a1775555994966a66e931"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3181df4583c4d3994d31fb235dc681d2aaad744fbdbf94c4802485ececdecf2"},
-    {file = "websockets-12.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:b067cb952ce8bf40115f6c19f478dc71c5e719b7fbaa511359795dfd9d1a6468"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:00700340c6c7ab788f176d118775202aadea7602c5cc6be6ae127761c16d6b0b"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e469d01137942849cff40517c97a30a93ae79917752b34029f0ec72df6b46399"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffefa1374cd508d633646d51a8e9277763a9b78ae71324183693959cf94635a7"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba0cab91b3956dfa9f512147860783a1829a8d905ee218a9837c18f683239611"},
-    {file = "websockets-12.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2cb388a5bfb56df4d9a406783b7f9dbefb888c09b71629351cc6b036e9259370"},
-    {file = "websockets-12.0-py3-none-any.whl", hash = "sha256:dc284bbc8d7c78a6c69e0c7325ab46ee5e40bb4d50e494d8131a07ef47500e9e"},
-    {file = "websockets-12.0.tar.gz", hash = "sha256:81df9cbcbb6c260de1e007e58c011bfebe2dafc8435107b0537f393dd38c8b1b"},
+    {file = "websockets-13.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ad4fa707ff9e2ffee019e946257b5300a45137a58f41fbd9a4db8e684ab61528"},
+    {file = "websockets-13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6fd757f313c13c34dae9f126d3ba4cf97175859c719e57c6a614b781c86b617e"},
+    {file = "websockets-13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cbac2eb7ce0fac755fb983c9247c4a60c4019bcde4c0e4d167aeb17520cc7ef1"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4b83cf7354cbbc058e97b3e545dceb75b8d9cf17fd5a19db419c319ddbaaf7a"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9202c0010c78fad1041e1c5285232b6508d3633f92825687549540a70e9e5901"},
+    {file = "websockets-13.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6566e79c8c7cbea75ec450f6e1828945fc5c9a4769ceb1c7b6e22470539712"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e7fcad070dcd9ad37a09d89a4cbc2a5e3e45080b88977c0da87b3090f9f55ead"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a8f7d65358a25172db00c69bcc7df834155ee24229f560d035758fd6613111a"},
+    {file = "websockets-13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:63b702fb31e3f058f946ccdfa551f4d57a06f7729c369e8815eb18643099db37"},
+    {file = "websockets-13.0-cp310-cp310-win32.whl", hash = "sha256:3a20cf14ba7b482c4a1924b5e061729afb89c890ca9ed44ac4127c6c5986e424"},
+    {file = "websockets-13.0-cp310-cp310-win_amd64.whl", hash = "sha256:587245f0704d0bb675f919898d7473e8827a6d578e5a122a21756ca44b811ec8"},
+    {file = "websockets-13.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:06df8306c241c235075d2ae77367038e701e53bc8c1bb4f6644f4f53aa6dedd0"},
+    {file = "websockets-13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:85a1f92a02f0b8c1bf02699731a70a8a74402bb3f82bee36e7768b19a8ed9709"},
+    {file = "websockets-13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9ed02c604349068d46d87ef4c2012c112c791f2bec08671903a6bb2bd9c06784"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b89849171b590107f6724a7b0790736daead40926ddf47eadf998b4ff51d6414"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:939a16849d71203628157a5e4a495da63967c744e1e32018e9b9e2689aca64d4"},
+    {file = "websockets-13.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad818cdac37c0ad4c58e51cb4964eae4f18b43c4a83cb37170b0d90c31bd80cf"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cbfe82a07596a044de78bb7a62519e71690c5812c26c5f1d4b877e64e4f46309"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e07e76c49f39c5b45cbd7362b94f001ae209a3ea4905ae9a09cfd53b3c76373d"},
+    {file = "websockets-13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:372f46a0096cfda23c88f7e42349a33f8375e10912f712e6b496d3a9a557290f"},
+    {file = "websockets-13.0-cp311-cp311-win32.whl", hash = "sha256:376a43a4fd96725f13450d3d2e98f4f36c3525c562ab53d9a98dd2950dca9a8a"},
+    {file = "websockets-13.0-cp311-cp311-win_amd64.whl", hash = "sha256:2be1382a4daa61e2f3e2be3b3c86932a8db9d1f85297feb6e9df22f391f94452"},
+    {file = "websockets-13.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5407c34776b9b77bd89a5f95eb0a34aaf91889e3f911c63f13035220eb50107"},
+    {file = "websockets-13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4782ec789f059f888c1e8fdf94383d0e64b531cffebbf26dd55afd53ab487ca4"},
+    {file = "websockets-13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c8feb8e19ef65c9994e652c5b0324abd657bedd0abeb946fb4f5163012c1e730"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3f3d2e20c442b58dbac593cb1e02bc02d149a86056cc4126d977ad902472e3b"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e39d393e0ab5b8bd01717cc26f2922026050188947ff54fe6a49dc489f7750b7"},
+    {file = "websockets-13.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f661a4205741bdc88ac9c2b2ec003c72cee97e4acd156eb733662ff004ba429"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:384129ad0490e06bab2b98c1da9b488acb35bb11e2464c728376c6f55f0d45f3"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:df5c0eff91f61b8205a6c9f7b255ff390cdb77b61c7b41f79ca10afcbb22b6cb"},
+    {file = "websockets-13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:02cc9bb1a887dac0e08bf657c5d00aa3fac0d03215d35a599130c2034ae6663a"},
+    {file = "websockets-13.0-cp312-cp312-win32.whl", hash = "sha256:d9726d2c9bd6aed8cb994d89b3910ca0079406edce3670886ec828a73e7bdd53"},
+    {file = "websockets-13.0-cp312-cp312-win_amd64.whl", hash = "sha256:fa0839f35322f7b038d8adcf679e2698c3a483688cc92e3bd15ee4fb06669e9a"},
+    {file = "websockets-13.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:da7e501e59857e8e3e9d10586139dc196b80445a591451ca9998aafba1af5278"},
+    {file = "websockets-13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a00e1e587c655749afb5b135d8d3edcfe84ec6db864201e40a882e64168610b3"},
+    {file = "websockets-13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a7fbf2a8fe7556a8f4e68cb3e736884af7bf93653e79f6219f17ebb75e97d8f0"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ea9c9c7443a97ea4d84d3e4d42d0e8c4235834edae652993abcd2aff94affd7"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:35c2221b539b360203f3f9ad168e527bf16d903e385068ae842c186efb13d0ea"},
+    {file = "websockets-13.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:358d37c5c431dd050ffb06b4b075505aae3f4f795d7fff9794e5ed96ce99b998"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:038e7a0f1bfafc7bf52915ab3506b7a03d1e06381e9f60440c856e8918138151"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fd038bc9e2c134847f1e0ce3191797fad110756e690c2fdd9702ed34e7a43abb"},
+    {file = "websockets-13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93b8c2008f372379fb6e5d2b3f7c9ec32f7b80316543fd3a5ace6610c5cde1b0"},
+    {file = "websockets-13.0-cp313-cp313-win32.whl", hash = "sha256:851fd0afb3bc0b73f7c5b5858975d42769a5fdde5314f4ef2c106aec63100687"},
+    {file = "websockets-13.0-cp313-cp313-win_amd64.whl", hash = "sha256:7d14901fdcf212804970c30ab9ee8f3f0212e620c7ea93079d6534863444fb4e"},
+    {file = "websockets-13.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ae7a519a56a714f64c3445cabde9fc2fc927e7eae44f413eae187cddd9e54178"},
+    {file = "websockets-13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5575031472ca87302aeb2ce2c2349f4c6ea978c86a9d1289bc5d16058ad4c10a"},
+    {file = "websockets-13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9895df6cd0bfe79d09bcd1dbdc03862846f26fbd93797153de954306620c1d00"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4de299c947a54fca9ce1c5fd4a08eb92ffce91961becb13bd9195f7c6e71b47"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05c25f7b849702950b6fd0e233989bb73a0d2bc83faa3b7233313ca395205f6d"},
+    {file = "websockets-13.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ede95125a30602b1691a4b1da88946bf27dae283cf30f22cd2cb8ca4b2e0d119"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:addf0a16e4983280efed272d8cb3b2e05f0051755372461e7d966b80a6554e16"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:06b3186e97bf9a33921fa60734d5ed90f2a9b407cce8d23c7333a0984049ef61"},
+    {file = "websockets-13.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:eae368cac85adc4c7dc3b0d5f84ffcca609d658db6447387300478e44db70796"},
+    {file = "websockets-13.0-cp38-cp38-win32.whl", hash = "sha256:337837ac788d955728b1ab01876d72b73da59819a3388e1c5e8e05c3999f1afa"},
+    {file = "websockets-13.0-cp38-cp38-win_amd64.whl", hash = "sha256:f66e00e42f25ca7e91076366303e11c82572ca87cc5aae51e6e9c094f315ab41"},
+    {file = "websockets-13.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:94c1c02721139fe9940b38d28fb15b4b782981d800d5f40f9966264fbf23dcc8"},
+    {file = "websockets-13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd4ba86513430513e2aa25a441bb538f6f83734dc368a2c5d18afdd39097aa33"},
+    {file = "websockets-13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a1ab8f0e0cadc5be5f3f9fa11a663957fecbf483d434762c8dfb8aa44948944a"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3670def5d3dfd5af6f6e2b3b243ea8f1f72d8da1ef927322f0703f85c90d9603"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6058b6be92743358885ad6dcdecb378fde4a4c74d4dd16a089d07580c75a0e80"},
+    {file = "websockets-13.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:516062a0a8ef5ecbfa4acbaec14b199fc070577834f9fe3d40800a99f92523ca"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:da7e918d82e7bdfc6f66d31febe1b2e28a1ca3387315f918de26f5e367f61572"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:9cc7f35dcb49a4e32db82a849fcc0714c4d4acc9d2273aded2d61f87d7f660b7"},
+    {file = "websockets-13.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f5737c53eb2c8ed8f64b50d3dafd3c1dae739f78aa495a288421ac1b3de82717"},
+    {file = "websockets-13.0-cp39-cp39-win32.whl", hash = "sha256:265e1f0d3f788ce8ef99dca591a1aec5263b26083ca0934467ad9a1d1181067c"},
+    {file = "websockets-13.0-cp39-cp39-win_amd64.whl", hash = "sha256:4d70c89e3d3b347a7c4d3c33f8d323f0584c9ceb69b82c2ef8a174ca84ea3d4a"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:602cbd010d8c21c8475f1798b705bb18567eb189c533ab5ef568bc3033fdf417"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:bf8eb5dca4f484a60f5327b044e842e0d7f7cdbf02ea6dc4a4f811259f1f1f0b"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d795c1802d99a643bf689b277e8604c14b5af1bc0a31dade2cd7a678087212"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:788bc841d250beccff67a20a5a53a15657a60111ef9c0c0a97fbdd614fae0fe2"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7334752052532c156d28b8eaf3558137e115c7871ea82adff69b6d94a7bee273"},
+    {file = "websockets-13.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7a1963302947332c3039e3f66209ec73b1626f8a0191649e0713c391e9f5b0d"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2e1cf4e1eb84b4fd74a47688e8b0940c89a04ad9f6937afa43d468e71128cd68"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:c026ee729c4ce55708a14b839ba35086dfae265fc12813b62d34ce33f4980c1c"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5f9d23fbbf96eefde836d9692670bfc89e2d159f456d499c5efcf6a6281c1af"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ad684cb7efce227d756bae3e8484f2e56aa128398753b54245efdfbd1108f2c"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1e10b3fbed7be4a59831d3a939900e50fcd34d93716e433d4193a4d0d1d335d"},
+    {file = "websockets-13.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d42a818e634f789350cd8fb413a3f5eec1cf0400a53d02062534c41519f5125c"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e5ba5e9b332267d0f2c33ede390061850f1ac3ee6cd1bdcf4c5ea33ead971966"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:f9af457ed593e35f467140d8b61d425495b127744a9d65d45a366f8678449a23"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcea3eb58c09c3a31cc83b45c06d5907f02ddaf10920aaa6443975310f699b95"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c210d1460dc8d326ffdef9703c2f83269b7539a1690ad11ae04162bc1878d33d"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b32f38bc81170fd56d0482d505b556e52bf9078b36819a8ba52624bd6667e39e"},
+    {file = "websockets-13.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:81a11a1ddd5320429db47c04d35119c3e674d215173d87aaeb06ae80f6e9031f"},
+    {file = "websockets-13.0-py3-none-any.whl", hash = "sha256:dbbac01e80aee253d44c4f098ab3cc17c822518519e869b284cfbb8cd16cc9de"},
+    {file = "websockets-13.0.tar.gz", hash = "sha256:b7bf950234a482b7461afdb2ec99eee3548ec4d53f418c7990bb79c620476602"},
 ]
 
 [[package]]
@@ -1421,4 +1370,4 @@ test = ["pytest (>=8.1,<9.0)"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "5305621bc02d824065519913f0d754e269f1e4525ba8796be08504120614259d"
+content-hash = "7d20e2d0c0c3c8f3a48d9160a2b4a11a5f353d23bb5d7a06ec527fe08e425b91"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastanime"
-version = "0.50.0"
+version = "2.4.0"
 description = "A browser anime site experience from the terminal"
 authors = ["Benextempest <benextempest@gmail.com>"]
 license = "UNLICENSE"
@@ -12,13 +12,9 @@ yt-dlp = "^2024.5.27"
 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"
 plyer = "^2.1.0"
-pyshortcuts = "^1.9.0"
 
 mpv = "^1.0.7"
 [tool.poetry.group.dev.dependencies]

pyrightconfig.json

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

tests/test_all_commands.py

@@ -45,6 +45,26 @@ 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_update_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["update", "--help"])
+    assert result.exit_code == 0
+
+
+def test_grab_help(runner: CliRunner):
+    result = runner.invoke(run_cli, ["grab", "--help"])
+    assert result.exit_code == 0
+
+
 def test_anilist_help(runner: CliRunner):
     result = runner.invoke(run_cli, ["anilist", "--help"])
     assert result.exit_code == 0